crate::c_types::IOError),
/// The message included zlib-compressed values, which we don't support.
UnsupportedCompression,
+ /// Value is validly encoded but is dangerous to use.
+ ///
+ /// This is used for things like [`ChannelManager`] deserialization where we want to ensure
+ /// that we don't use a [`ChannelManager`] which is in out of sync with the [`ChannelMonitor`].
+ /// This indicates that there is a critical implementation flaw in the storage implementation
+ /// and it's unsafe to continue.
+ ///
+ /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+ DangerousValue,
}
use lightning::ln::msgs::DecodeError as DecodeErrorImport;
pub(crate) type nativeDecodeError = DecodeErrorImport;
)
},
DecodeError::UnsupportedCompression => nativeDecodeError::UnsupportedCompression,
+ DecodeError::DangerousValue => nativeDecodeError::DangerousValue,
}
}
#[allow(unused)]
)
},
DecodeError::UnsupportedCompression => nativeDecodeError::UnsupportedCompression,
+ DecodeError::DangerousValue => nativeDecodeError::DangerousValue,
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeDecodeError) -> Self {
+ pub(crate) fn from_native(native: &DecodeErrorImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeDecodeError) };
match native {
nativeDecodeError::UnknownVersion => DecodeError::UnknownVersion,
nativeDecodeError::UnknownRequiredFeature => DecodeError::UnknownRequiredFeature,
)
},
nativeDecodeError::UnsupportedCompression => DecodeError::UnsupportedCompression,
+ nativeDecodeError::DangerousValue => DecodeError::DangerousValue,
}
}
#[allow(unused)]
)
},
nativeDecodeError::UnsupportedCompression => DecodeError::UnsupportedCompression,
+ nativeDecodeError::DangerousValue => DecodeError::DangerousValue,
}
}
}
/// Utility method to constructs a new UnsupportedCompression-variant DecodeError
pub extern "C" fn DecodeError_unsupported_compression() -> DecodeError {
DecodeError::UnsupportedCompression}
+#[no_mangle]
+/// Utility method to constructs a new DangerousValue-variant DecodeError
+pub extern "C" fn DecodeError_dangerous_value() -> DecodeError {
+ DecodeError::DangerousValue}
+/// Get a string which allows debug introspection of a DecodeError object
+pub extern "C" fn DecodeError_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::DecodeError }).into()}
+/// Generates a non-cryptographic 64-bit hash of the DecodeError.
+#[no_mangle]
+pub extern "C" fn DecodeError_hash(o: &DecodeError) -> u64 {
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(&o.to_native(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two DecodeErrors contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
#[no_mangle]
pub extern "C" fn Init_get_networks(this_ptr: &Init) -> crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ {
let mut inner_val = this_ptr.get_native_mut_ref().networks.clone();
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ::None } else { crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ::Some( { let mut local_inner_val_0 = Vec::new(); for mut item in inner_val.unwrap().drain(..) { local_inner_val_0.push( { crate::c_types::ThirtyTwoBytes { data: item.to_bytes() } }); }; local_inner_val_0.into() }) };
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ::None } else { crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ::Some( { let mut local_inner_val_0 = Vec::new(); for mut item in inner_val.unwrap().drain(..) { local_inner_val_0.push( { crate::c_types::ThirtyTwoBytes { data: *item.as_ref() } }); }; local_inner_val_0.into() }) };
local_inner_val
}
/// Indicates chains the sender is interested in.
/// If there are no common chains, the connection will be closed.
#[no_mangle]
pub extern "C" fn Init_set_networks(this_ptr: &mut Init, mut val: crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { let mut local_val_0 = Vec::new(); for mut item in { val_opt.take() }.into_rust().drain(..) { local_val_0.push( { ::bitcoin::blockdata::constants::ChainHash::from(&item.data[..]) }); }; local_val_0 }})} };
+ let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { let mut local_val_0 = Vec::new(); for mut item in { val_opt.take() }.into_rust().drain(..) { local_val_0.push( { ::bitcoin::blockdata::constants::ChainHash::from(&item.data) }); }; local_val_0 }})} };
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.networks = local_val;
}
/// The receipient's network address.
#[must_use]
#[no_mangle]
pub extern "C" fn Init_new(mut features_arg: crate::lightning::ln::features::InitFeatures, mut networks_arg: crate::c_types::derived::COption_CVec_ThirtyTwoBytesZZ, mut remote_network_address_arg: crate::c_types::derived::COption_SocketAddressZ) -> Init {
- let mut local_networks_arg = { /*networks_arg*/ let networks_arg_opt = networks_arg; if networks_arg_opt.is_none() { None } else { Some({ { let mut local_networks_arg_0 = Vec::new(); for mut item in { networks_arg_opt.take() }.into_rust().drain(..) { local_networks_arg_0.push( { ::bitcoin::blockdata::constants::ChainHash::from(&item.data[..]) }); }; local_networks_arg_0 }})} };
+ let mut local_networks_arg = { /*networks_arg*/ let networks_arg_opt = networks_arg; if networks_arg_opt.is_none() { None } else { Some({ { let mut local_networks_arg_0 = Vec::new(); for mut item in { networks_arg_opt.take() }.into_rust().drain(..) { local_networks_arg_0.push( { ::bitcoin::blockdata::constants::ChainHash::from(&item.data) }); }; local_networks_arg_0 }})} };
let mut local_remote_network_address_arg = { /*remote_network_address_arg*/ let remote_network_address_arg_opt = remote_network_address_arg; if remote_network_address_arg_opt.is_none() { None } else { Some({ { { remote_network_address_arg_opt.take() }.into_native() }})} };
Init { inner: ObjOps::heap_alloc(nativeInit {
features: *unsafe { Box::from_raw(features_arg.take_inner()) },
pub extern "C" fn Init_clone(orig: &Init) -> Init {
orig.clone()
}
+/// Get a string which allows debug introspection of a Init object
+pub extern "C" fn Init_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::Init }).into()}
+/// Generates a non-cryptographic 64-bit hash of the Init.
+#[no_mangle]
+pub extern "C" fn Init_hash(o: &Init) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two Inits contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
/// All-0s indicates a general error unrelated to a specific channel, after which all channels
/// with the sending peer should be closed.
#[no_mangle]
-pub extern "C" fn ErrorMessage_get_channel_id(this_ptr: &ErrorMessage) -> *const [u8; 32] {
+pub extern "C" fn ErrorMessage_get_channel_id(this_ptr: &ErrorMessage) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID involved in the error.
///
/// All-0s indicates a general error unrelated to a specific channel, after which all channels
/// with the sending peer should be closed.
#[no_mangle]
-pub extern "C" fn ErrorMessage_set_channel_id(this_ptr: &mut ErrorMessage, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn ErrorMessage_set_channel_id(this_ptr: &mut ErrorMessage, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
/// A possibly human-readable error description.
///
/// Constructs a new ErrorMessage given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn ErrorMessage_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::Str) -> ErrorMessage {
+pub extern "C" fn ErrorMessage_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut data_arg: crate::c_types::Str) -> ErrorMessage {
ErrorMessage { inner: ObjOps::heap_alloc(nativeErrorMessage {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
data: data_arg.into_string(),
}), is_owned: true }
}
pub extern "C" fn ErrorMessage_clone(orig: &ErrorMessage) -> ErrorMessage {
orig.clone()
}
+/// Get a string which allows debug introspection of a ErrorMessage object
+pub extern "C" fn ErrorMessage_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ErrorMessage }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ErrorMessage.
+#[no_mangle]
+pub extern "C" fn ErrorMessage_hash(o: &ErrorMessage) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two ErrorMessages contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
///
/// All-0s indicates a warning unrelated to a specific channel.
#[no_mangle]
-pub extern "C" fn WarningMessage_get_channel_id(this_ptr: &WarningMessage) -> *const [u8; 32] {
+pub extern "C" fn WarningMessage_get_channel_id(this_ptr: &WarningMessage) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID involved in the warning.
///
/// All-0s indicates a warning unrelated to a specific channel.
#[no_mangle]
-pub extern "C" fn WarningMessage_set_channel_id(this_ptr: &mut WarningMessage, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn WarningMessage_set_channel_id(this_ptr: &mut WarningMessage, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
/// A possibly human-readable warning description.
///
/// Constructs a new WarningMessage given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn WarningMessage_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::Str) -> WarningMessage {
+pub extern "C" fn WarningMessage_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut data_arg: crate::c_types::Str) -> WarningMessage {
WarningMessage { inner: ObjOps::heap_alloc(nativeWarningMessage {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
data: data_arg.into_string(),
}), is_owned: true }
}
pub extern "C" fn WarningMessage_clone(orig: &WarningMessage) -> WarningMessage {
orig.clone()
}
+/// Get a string which allows debug introspection of a WarningMessage object
+pub extern "C" fn WarningMessage_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::WarningMessage }).into()}
+/// Generates a non-cryptographic 64-bit hash of the WarningMessage.
+#[no_mangle]
+pub extern "C" fn WarningMessage_hash(o: &WarningMessage) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two WarningMessages contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub extern "C" fn Ping_clone(orig: &Ping) -> Ping {
orig.clone()
}
+/// Get a string which allows debug introspection of a Ping object
+pub extern "C" fn Ping_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::Ping }).into()}
+/// Generates a non-cryptographic 64-bit hash of the Ping.
+#[no_mangle]
+pub extern "C" fn Ping_hash(o: &Ping) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two Pings contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub extern "C" fn Pong_clone(orig: &Pong) -> Pong {
orig.clone()
}
+/// Get a string which allows debug introspection of a Pong object
+pub extern "C" fn Pong_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::Pong }).into()}
+/// Generates a non-cryptographic 64-bit hash of the Pong.
+#[no_mangle]
+pub extern "C" fn Pong_hash(o: &Pong) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two Pongs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::OpenChannel as nativeOpenChannelImport;
-pub(crate) type nativeOpenChannel = nativeOpenChannelImport;
+use lightning::ln::msgs::CommonOpenChannelFields as nativeCommonOpenChannelFieldsImport;
+pub(crate) type nativeCommonOpenChannelFields = nativeCommonOpenChannelFieldsImport;
-/// An [`open_channel`] message to be sent to or received from a peer.
-///
-/// Used in V1 channel establishment
+/// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
///
/// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
#[must_use]
#[repr(C)]
-pub struct OpenChannel {
+pub struct CommonOpenChannelFields {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeOpenChannel,
+ pub inner: *mut nativeCommonOpenChannelFields,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for OpenChannel {
+impl Drop for CommonOpenChannelFields {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeOpenChannel>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeCommonOpenChannelFields>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the OpenChannel, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the CommonOpenChannelFields, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn OpenChannel_free(this_obj: OpenChannel) { }
+pub extern "C" fn CommonOpenChannelFields_free(this_obj: CommonOpenChannelFields) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn OpenChannel_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeOpenChannel) };
+pub(crate) extern "C" fn CommonOpenChannelFields_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeCommonOpenChannelFields) };
}
#[allow(unused)]
-impl OpenChannel {
- pub(crate) fn get_native_ref(&self) -> &'static nativeOpenChannel {
+impl CommonOpenChannelFields {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeCommonOpenChannelFields {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeOpenChannel {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeCommonOpenChannelFields {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeOpenChannel {
+ pub(crate) fn take_inner(mut self) -> *mut nativeCommonOpenChannelFields {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// 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] {
+pub extern "C" fn CommonOpenChannelFields_get_chain_hash(this_ptr: &CommonOpenChannelFields) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain where the channel is to be opened
#[no_mangle]
-pub extern "C" fn OpenChannel_set_chain_hash(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+pub extern "C" fn CommonOpenChannelFields_set_chain_hash(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
-/// A temporary channel ID, until the funding outpoint is announced
+/// A temporary channel ID
+/// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
+/// For V1 channels: a temporary channel ID, until the funding outpoint is announced
#[no_mangle]
-pub extern "C" fn OpenChannel_get_temporary_channel_id(this_ptr: &OpenChannel) -> *const [u8; 32] {
+pub extern "C" fn CommonOpenChannelFields_get_temporary_channel_id(this_ptr: &CommonOpenChannelFields) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
-/// A temporary channel ID, until the funding outpoint is announced
+/// A temporary channel ID
+/// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
+/// For V1 channels: a temporary channel ID, until the funding outpoint is announced
#[no_mangle]
-pub extern "C" fn OpenChannel_set_temporary_channel_id(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn CommonOpenChannelFields_set_temporary_channel_id(this_ptr: &mut CommonOpenChannelFields, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The channel value
+/// For V1 channels: The channel value
+/// For V2 channels: Part of the channel value contributed by the channel initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_get_funding_satoshis(this_ptr: &OpenChannel) -> u64 {
+pub extern "C" fn CommonOpenChannelFields_get_funding_satoshis(this_ptr: &CommonOpenChannelFields) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_satoshis;
*inner_val
}
-/// The channel value
+/// For V1 channels: The channel value
+/// For V2 channels: Part of the channel value contributed by the channel initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_set_funding_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
+pub extern "C" fn CommonOpenChannelFields_set_funding_satoshis(this_ptr: &mut CommonOpenChannelFields, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_satoshis = val;
}
-/// The amount to push to the counterparty as part of the open, in milli-satoshi
-#[no_mangle]
-pub extern "C" fn OpenChannel_get_push_msat(this_ptr: &OpenChannel) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().push_msat;
- *inner_val
-}
-/// The amount to push to the counterparty as part of the open, in milli-satoshi
-#[no_mangle]
-pub extern "C" fn OpenChannel_set_push_msat(this_ptr: &mut OpenChannel, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.push_msat = val;
-}
-/// The threshold below which outputs on transactions broadcast by sender will be omitted
+/// The threshold below which outputs on transactions broadcast by the channel initiator will be
+/// omitted
#[no_mangle]
-pub extern "C" fn OpenChannel_get_dust_limit_satoshis(this_ptr: &OpenChannel) -> u64 {
+pub extern "C" fn CommonOpenChannelFields_get_dust_limit_satoshis(this_ptr: &CommonOpenChannelFields) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
*inner_val
}
-/// The threshold below which outputs on transactions broadcast by sender will be omitted
+/// The threshold below which outputs on transactions broadcast by the channel initiator will be
+/// omitted
#[no_mangle]
-pub extern "C" fn OpenChannel_set_dust_limit_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
+pub extern "C" fn CommonOpenChannelFields_set_dust_limit_satoshis(this_ptr: &mut CommonOpenChannelFields, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
}
-/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
+/// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: &OpenChannel) -> u64 {
+pub extern "C" fn CommonOpenChannelFields_get_max_htlc_value_in_flight_msat(this_ptr: &CommonOpenChannelFields) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().max_htlc_value_in_flight_msat;
*inner_val
}
-/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
+/// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut OpenChannel, mut val: u64) {
+pub extern "C" fn CommonOpenChannelFields_set_max_htlc_value_in_flight_msat(this_ptr: &mut CommonOpenChannelFields, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_htlc_value_in_flight_msat = val;
}
-/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
-#[no_mangle]
-pub extern "C" fn OpenChannel_get_channel_reserve_satoshis(this_ptr: &OpenChannel) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_reserve_satoshis;
- *inner_val
-}
-/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
-#[no_mangle]
-pub extern "C" fn OpenChannel_set_channel_reserve_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_reserve_satoshis = val;
-}
-/// The minimum HTLC size incoming to sender, in milli-satoshi
+/// The minimum HTLC size incoming to channel initiator, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannel_get_htlc_minimum_msat(this_ptr: &OpenChannel) -> u64 {
+pub extern "C" fn CommonOpenChannelFields_get_htlc_minimum_msat(this_ptr: &CommonOpenChannelFields) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
*inner_val
}
-/// The minimum HTLC size incoming to sender, in milli-satoshi
+/// The minimum HTLC size incoming to channel initiator, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannel_set_htlc_minimum_msat(this_ptr: &mut OpenChannel, mut val: u64) {
+pub extern "C" fn CommonOpenChannelFields_set_htlc_minimum_msat(this_ptr: &mut CommonOpenChannelFields, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
}
-/// The feerate per 1000-weight of sender generated transactions, until updated by
+/// The feerate for the commitment transaction set by the channel initiator until updated by
/// [`UpdateFee`]
#[no_mangle]
-pub extern "C" fn OpenChannel_get_feerate_per_kw(this_ptr: &OpenChannel) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_per_kw;
+pub extern "C" fn CommonOpenChannelFields_get_commitment_feerate_sat_per_1000_weight(this_ptr: &CommonOpenChannelFields) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().commitment_feerate_sat_per_1000_weight;
*inner_val
}
-/// The feerate per 1000-weight of sender generated transactions, until updated by
+/// The feerate for the commitment transaction set by the channel initiator until updated by
/// [`UpdateFee`]
#[no_mangle]
-pub extern "C" fn OpenChannel_set_feerate_per_kw(this_ptr: &mut OpenChannel, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_per_kw = val;
+pub extern "C" fn CommonOpenChannelFields_set_commitment_feerate_sat_per_1000_weight(this_ptr: &mut CommonOpenChannelFields, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.commitment_feerate_sat_per_1000_weight = val;
}
-/// The number of blocks which the counterparty will have to wait to claim on-chain funds if
-/// they broadcast a commitment transaction
+/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
+/// broadcast a commitment transaction
#[no_mangle]
-pub extern "C" fn OpenChannel_get_to_self_delay(this_ptr: &OpenChannel) -> u16 {
+pub extern "C" fn CommonOpenChannelFields_get_to_self_delay(this_ptr: &CommonOpenChannelFields) -> u16 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().to_self_delay;
*inner_val
}
-/// The number of blocks which the counterparty will have to wait to claim on-chain funds if
-/// they broadcast a commitment transaction
+/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
+/// broadcast a commitment transaction
#[no_mangle]
-pub extern "C" fn OpenChannel_set_to_self_delay(this_ptr: &mut OpenChannel, mut val: u16) {
+pub extern "C" fn CommonOpenChannelFields_set_to_self_delay(this_ptr: &mut CommonOpenChannelFields, mut val: u16) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.to_self_delay = val;
}
-/// The maximum number of inbound HTLCs towards sender
+/// The maximum number of inbound HTLCs towards channel initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_get_max_accepted_htlcs(this_ptr: &OpenChannel) -> u16 {
+pub extern "C" fn CommonOpenChannelFields_get_max_accepted_htlcs(this_ptr: &CommonOpenChannelFields) -> u16 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().max_accepted_htlcs;
*inner_val
}
-/// The maximum number of inbound HTLCs towards sender
+/// The maximum number of inbound HTLCs towards channel initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_set_max_accepted_htlcs(this_ptr: &mut OpenChannel, mut val: u16) {
+pub extern "C" fn CommonOpenChannelFields_set_max_accepted_htlcs(this_ptr: &mut CommonOpenChannelFields, mut val: u16) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_accepted_htlcs = val;
}
-/// The sender's key controlling the funding transaction
+/// The channel initiator's key controlling the funding transaction
#[no_mangle]
-pub extern "C" fn OpenChannel_get_funding_pubkey(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonOpenChannelFields_get_funding_pubkey(this_ptr: &CommonOpenChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// The sender's key controlling the funding transaction
+/// The channel initiator's key controlling the funding transaction
#[no_mangle]
-pub extern "C" fn OpenChannel_set_funding_pubkey(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonOpenChannelFields_set_funding_pubkey(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
}
/// Used to derive a revocation key for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannel_get_revocation_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonOpenChannelFields_get_revocation_basepoint(this_ptr: &CommonOpenChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().revocation_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
/// Used to derive a revocation key for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannel_set_revocation_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonOpenChannelFields_set_revocation_basepoint(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.revocation_basepoint = val.into_rust();
}
-/// A payment key to sender for transactions broadcast by counterparty
+/// A payment key to channel initiator for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannel_get_payment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_point;
+pub extern "C" fn CommonOpenChannelFields_get_payment_basepoint(this_ptr: &CommonOpenChannelFields) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// A payment key to sender for transactions broadcast by counterparty
+/// A payment key to channel initiator for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannel_set_payment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_point = val.into_rust();
+pub extern "C" fn CommonOpenChannelFields_set_payment_basepoint(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_basepoint = val.into_rust();
}
-/// Used to derive a payment key to sender for transactions broadcast by sender
+/// Used to derive a payment key to channel initiator for transactions broadcast by channel
+/// initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_get_delayed_payment_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonOpenChannelFields_get_delayed_payment_basepoint(this_ptr: &CommonOpenChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().delayed_payment_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// Used to derive a payment key to sender for transactions broadcast by sender
+/// Used to derive a payment key to channel initiator for transactions broadcast by channel
+/// initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_set_delayed_payment_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonOpenChannelFields_set_delayed_payment_basepoint(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.delayed_payment_basepoint = val.into_rust();
}
-/// Used to derive an HTLC payment key to sender
+/// Used to derive an HTLC payment key to channel initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_get_htlc_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonOpenChannelFields_get_htlc_basepoint(this_ptr: &CommonOpenChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// Used to derive an HTLC payment key to sender
+/// Used to derive an HTLC payment key to channel initiator
#[no_mangle]
-pub extern "C" fn OpenChannel_set_htlc_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonOpenChannelFields_set_htlc_basepoint(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_basepoint = val.into_rust();
}
-/// The first to-be-broadcast-by-sender transaction's per commitment point
+/// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
#[no_mangle]
-pub extern "C" fn OpenChannel_get_first_per_commitment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonOpenChannelFields_get_first_per_commitment_point(this_ptr: &CommonOpenChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().first_per_commitment_point;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// The first to-be-broadcast-by-sender transaction's per commitment point
+/// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
#[no_mangle]
-pub extern "C" fn OpenChannel_set_first_per_commitment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonOpenChannelFields_set_first_per_commitment_point(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_per_commitment_point = val.into_rust();
}
/// The channel flags to be used
#[no_mangle]
-pub extern "C" fn OpenChannel_get_channel_flags(this_ptr: &OpenChannel) -> u8 {
+pub extern "C" fn CommonOpenChannelFields_get_channel_flags(this_ptr: &CommonOpenChannelFields) -> u8 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_flags;
*inner_val
}
/// The channel flags to be used
#[no_mangle]
-pub extern "C" fn OpenChannel_set_channel_flags(this_ptr: &mut OpenChannel, mut val: u8) {
+pub extern "C" fn CommonOpenChannelFields_set_channel_flags(this_ptr: &mut CommonOpenChannelFields, mut val: u8) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_flags = val;
}
-/// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
+/// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
+/// collaboratively close
#[no_mangle]
-pub extern "C" fn OpenChannel_get_shutdown_scriptpubkey(this_ptr: &OpenChannel) -> crate::c_types::derived::COption_CVec_u8ZZ {
+pub extern "C" fn CommonOpenChannelFields_get_shutdown_scriptpubkey(this_ptr: &CommonOpenChannelFields) -> crate::c_types::derived::COption_CVec_u8ZZ {
let mut inner_val = &mut this_ptr.get_native_mut_ref().shutdown_scriptpubkey;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { (*inner_val.as_ref().unwrap()).clone().into_bytes().into() }) };
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { (*inner_val.as_ref().unwrap()).clone().to_bytes().into() }) };
local_inner_val
}
-/// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
+/// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
+/// collaboratively close
#[no_mangle]
-pub extern "C" fn OpenChannel_set_shutdown_scriptpubkey(this_ptr: &mut OpenChannel, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ val_opt.take() }.into_rust()) }})} };
+pub extern "C" fn CommonOpenChannelFields_set_shutdown_scriptpubkey(this_ptr: &mut CommonOpenChannelFields, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
+ let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::ScriptBuf::from({ val_opt.take() }.into_rust()) }})} };
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.shutdown_scriptpubkey = local_val;
}
/// The channel type that this channel will represent
///
/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
#[no_mangle]
-pub extern "C" fn OpenChannel_get_channel_type(this_ptr: &OpenChannel) -> crate::lightning::ln::features::ChannelTypeFeatures {
+pub extern "C" fn CommonOpenChannelFields_get_channel_type(this_ptr: &CommonOpenChannelFields) -> crate::lightning::ln::features::ChannelTypeFeatures {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_type;
let mut local_inner_val = crate::lightning::ln::features::ChannelTypeFeatures { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::features::ChannelTypeFeatures<>) as *mut _ }, is_owned: false };
local_inner_val
///
/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
#[no_mangle]
-pub extern "C" fn OpenChannel_set_channel_type(this_ptr: &mut OpenChannel, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
+pub extern "C" fn CommonOpenChannelFields_set_channel_type(this_ptr: &mut CommonOpenChannelFields, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_type = local_val;
}
-/// Constructs a new OpenChannel given each field
+/// Constructs a new CommonOpenChannelFields given each field
///
/// Note that channel_type_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
#[must_use]
#[no_mangle]
-pub extern "C" fn OpenChannel_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_satoshis_arg: u64, mut push_msat_arg: u64, mut dust_limit_satoshis_arg: u64, mut max_htlc_value_in_flight_msat_arg: u64, mut channel_reserve_satoshis_arg: u64, mut htlc_minimum_msat_arg: u64, mut feerate_per_kw_arg: u32, mut to_self_delay_arg: u16, mut max_accepted_htlcs_arg: u16, mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_point_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey, mut first_per_commitment_point_arg: crate::c_types::PublicKey, mut channel_flags_arg: u8, mut shutdown_scriptpubkey_arg: crate::c_types::derived::COption_CVec_u8ZZ, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures) -> OpenChannel {
- let mut local_shutdown_scriptpubkey_arg = { /*shutdown_scriptpubkey_arg*/ let shutdown_scriptpubkey_arg_opt = shutdown_scriptpubkey_arg; if shutdown_scriptpubkey_arg_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ shutdown_scriptpubkey_arg_opt.take() }.into_rust()) }})} };
+pub extern "C" fn CommonOpenChannelFields_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut temporary_channel_id_arg: crate::lightning::ln::types::ChannelId, mut funding_satoshis_arg: u64, mut dust_limit_satoshis_arg: u64, mut max_htlc_value_in_flight_msat_arg: u64, mut htlc_minimum_msat_arg: u64, mut commitment_feerate_sat_per_1000_weight_arg: u32, mut to_self_delay_arg: u16, mut max_accepted_htlcs_arg: u16, mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_basepoint_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey, mut first_per_commitment_point_arg: crate::c_types::PublicKey, mut channel_flags_arg: u8, mut shutdown_scriptpubkey_arg: crate::c_types::derived::COption_CVec_u8ZZ, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures) -> CommonOpenChannelFields {
+ let mut local_shutdown_scriptpubkey_arg = { /*shutdown_scriptpubkey_arg*/ let shutdown_scriptpubkey_arg_opt = shutdown_scriptpubkey_arg; if shutdown_scriptpubkey_arg_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::ScriptBuf::from({ shutdown_scriptpubkey_arg_opt.take() }.into_rust()) }})} };
let mut local_channel_type_arg = if channel_type_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_type_arg.take_inner()) } }) };
- OpenChannel { inner: ObjOps::heap_alloc(nativeOpenChannel {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
- temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_arg.data),
+ CommonOpenChannelFields { inner: ObjOps::heap_alloc(nativeCommonOpenChannelFields {
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
+ temporary_channel_id: *unsafe { Box::from_raw(temporary_channel_id_arg.take_inner()) },
funding_satoshis: funding_satoshis_arg,
- push_msat: push_msat_arg,
dust_limit_satoshis: dust_limit_satoshis_arg,
max_htlc_value_in_flight_msat: max_htlc_value_in_flight_msat_arg,
- channel_reserve_satoshis: channel_reserve_satoshis_arg,
htlc_minimum_msat: htlc_minimum_msat_arg,
- feerate_per_kw: feerate_per_kw_arg,
+ commitment_feerate_sat_per_1000_weight: commitment_feerate_sat_per_1000_weight_arg,
to_self_delay: to_self_delay_arg,
max_accepted_htlcs: max_accepted_htlcs_arg,
funding_pubkey: funding_pubkey_arg.into_rust(),
revocation_basepoint: revocation_basepoint_arg.into_rust(),
- payment_point: payment_point_arg.into_rust(),
+ payment_basepoint: payment_basepoint_arg.into_rust(),
delayed_payment_basepoint: delayed_payment_basepoint_arg.into_rust(),
htlc_basepoint: htlc_basepoint_arg.into_rust(),
first_per_commitment_point: first_per_commitment_point_arg.into_rust(),
channel_type: local_channel_type_arg,
}), is_owned: true }
}
+impl Clone for CommonOpenChannelFields {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeCommonOpenChannelFields>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 CommonOpenChannelFields_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeCommonOpenChannelFields)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the CommonOpenChannelFields
+pub extern "C" fn CommonOpenChannelFields_clone(orig: &CommonOpenChannelFields) -> CommonOpenChannelFields {
+ orig.clone()
+}
+/// Get a string which allows debug introspection of a CommonOpenChannelFields object
+pub extern "C" fn CommonOpenChannelFields_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::CommonOpenChannelFields }).into()}
+/// Generates a non-cryptographic 64-bit hash of the CommonOpenChannelFields.
+#[no_mangle]
+pub extern "C" fn CommonOpenChannelFields_hash(o: &CommonOpenChannelFields) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two CommonOpenChannelFieldss contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn CommonOpenChannelFields_eq(a: &CommonOpenChannelFields, b: &CommonOpenChannelFields) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+
+use lightning::ln::msgs::OpenChannel as nativeOpenChannelImport;
+pub(crate) type nativeOpenChannel = nativeOpenChannelImport;
+
+/// An [`open_channel`] message to be sent to or received from a peer.
+///
+/// Used in V1 channel establishment
+///
+/// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
+#[must_use]
+#[repr(C)]
+pub struct OpenChannel {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeOpenChannel,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for OpenChannel {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeOpenChannel>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the OpenChannel, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn OpenChannel_free(this_obj: OpenChannel) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn OpenChannel_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeOpenChannel) };
+}
+#[allow(unused)]
+impl OpenChannel {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeOpenChannel {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeOpenChannel {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeOpenChannel {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// Common fields of `open_channel(2)`-like messages
+#[no_mangle]
+pub extern "C" fn OpenChannel_get_common_fields(this_ptr: &OpenChannel) -> crate::lightning::ln::msgs::CommonOpenChannelFields {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().common_fields;
+ crate::lightning::ln::msgs::CommonOpenChannelFields { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::CommonOpenChannelFields<>) as *mut _) }, is_owned: false }
+}
+/// Common fields of `open_channel(2)`-like messages
+#[no_mangle]
+pub extern "C" fn OpenChannel_set_common_fields(this_ptr: &mut OpenChannel, mut val: crate::lightning::ln::msgs::CommonOpenChannelFields) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.common_fields = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The amount to push to the counterparty as part of the open, in milli-satoshi
+#[no_mangle]
+pub extern "C" fn OpenChannel_get_push_msat(this_ptr: &OpenChannel) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().push_msat;
+ *inner_val
+}
+/// The amount to push to the counterparty as part of the open, in milli-satoshi
+#[no_mangle]
+pub extern "C" fn OpenChannel_set_push_msat(this_ptr: &mut OpenChannel, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.push_msat = val;
+}
+/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
+#[no_mangle]
+pub extern "C" fn OpenChannel_get_channel_reserve_satoshis(this_ptr: &OpenChannel) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_reserve_satoshis;
+ *inner_val
+}
+/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
+#[no_mangle]
+pub extern "C" fn OpenChannel_set_channel_reserve_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_reserve_satoshis = val;
+}
+/// Constructs a new OpenChannel given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn OpenChannel_new(mut common_fields_arg: crate::lightning::ln::msgs::CommonOpenChannelFields, mut push_msat_arg: u64, mut channel_reserve_satoshis_arg: u64) -> OpenChannel {
+ OpenChannel { inner: ObjOps::heap_alloc(nativeOpenChannel {
+ common_fields: *unsafe { Box::from_raw(common_fields_arg.take_inner()) },
+ push_msat: push_msat_arg,
+ channel_reserve_satoshis: channel_reserve_satoshis_arg,
+ }), is_owned: true }
+}
impl Clone for OpenChannel {
fn clone(&self) -> Self {
Self {
pub extern "C" fn OpenChannel_clone(orig: &OpenChannel) -> OpenChannel {
orig.clone()
}
+/// Get a string which allows debug introspection of a OpenChannel object
+pub extern "C" fn OpenChannel_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::OpenChannel }).into()}
+/// Generates a non-cryptographic 64-bit hash of the OpenChannel.
+#[no_mangle]
+pub extern "C" fn OpenChannel_hash(o: &OpenChannel) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two OpenChannels contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
ret
}
}
-/// The genesis hash of the blockchain where the channel is to be opened
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_chain_hash(this_ptr: &OpenChannelV2) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
-}
-/// The genesis hash of the blockchain where the channel is to be opened
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_chain_hash(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
-}
-/// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
+/// Common fields of `open_channel(2)`-like messages
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_temporary_channel_id(this_ptr: &OpenChannelV2) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
- &inner_val.0
+pub extern "C" fn OpenChannelV2_get_common_fields(this_ptr: &OpenChannelV2) -> crate::lightning::ln::msgs::CommonOpenChannelFields {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().common_fields;
+ crate::lightning::ln::msgs::CommonOpenChannelFields { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::CommonOpenChannelFields<>) as *mut _) }, is_owned: false }
}
-/// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
+/// Common fields of `open_channel(2)`-like messages
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_temporary_channel_id(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn OpenChannelV2_set_common_fields(this_ptr: &mut OpenChannelV2, mut val: crate::lightning::ln::msgs::CommonOpenChannelFields) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.common_fields = *unsafe { Box::from_raw(val.take_inner()) };
}
/// The feerate for the funding transaction set by the channel initiator
#[no_mangle]
pub extern "C" fn OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr: &mut OpenChannelV2, mut val: u32) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_feerate_sat_per_1000_weight = val;
}
-/// The feerate for the commitment transaction set by the channel initiator
+/// The locktime for the funding transaction
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr: &OpenChannelV2) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().commitment_feerate_sat_per_1000_weight;
+pub extern "C" fn OpenChannelV2_get_locktime(this_ptr: &OpenChannelV2) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().locktime;
*inner_val
}
-/// The feerate for the commitment transaction set by the channel initiator
+/// The locktime for the funding transaction
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr: &mut OpenChannelV2, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.commitment_feerate_sat_per_1000_weight = val;
+pub extern "C" fn OpenChannelV2_set_locktime(this_ptr: &mut OpenChannelV2, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.locktime = val;
}
-/// Part of the channel value contributed by the channel initiator
+/// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_funding_satoshis(this_ptr: &OpenChannelV2) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_satoshis;
- *inner_val
+pub extern "C" fn OpenChannelV2_get_second_per_commitment_point(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().second_per_commitment_point;
+ crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// Part of the channel value contributed by the channel initiator
+/// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_funding_satoshis(this_ptr: &mut OpenChannelV2, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_satoshis = val;
+pub extern "C" fn OpenChannelV2_set_second_per_commitment_point(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.second_per_commitment_point = val.into_rust();
}
-/// The threshold below which outputs on transactions broadcast by the channel initiator will be
-/// omitted
+/// Optionally, a requirement that only confirmed inputs can be added
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_dust_limit_satoshis(this_ptr: &OpenChannelV2) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
- *inner_val
+pub extern "C" fn OpenChannelV2_get_require_confirmed_inputs(this_ptr: &OpenChannelV2) -> crate::c_types::derived::COption_NoneZ {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().require_confirmed_inputs;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NoneZ::None } else { crate::c_types::derived::COption_NoneZ::Some /* { () /**/ } */ };
+ local_inner_val
}
-/// The threshold below which outputs on transactions broadcast by the channel initiator will be
-/// omitted
+/// Optionally, a requirement that only confirmed inputs can be added
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_dust_limit_satoshis(this_ptr: &mut OpenChannelV2, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
+pub extern "C" fn OpenChannelV2_set_require_confirmed_inputs(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::derived::COption_NoneZ) {
+ let mut local_val = if val.is_some() { Some( { () /*val.take()*/ }) } else { None };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.require_confirmed_inputs = local_val;
}
-/// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
+/// Constructs a new OpenChannelV2 given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn OpenChannelV2_new(mut common_fields_arg: crate::lightning::ln::msgs::CommonOpenChannelFields, mut funding_feerate_sat_per_1000_weight_arg: u32, mut locktime_arg: u32, mut second_per_commitment_point_arg: crate::c_types::PublicKey, mut require_confirmed_inputs_arg: crate::c_types::derived::COption_NoneZ) -> OpenChannelV2 {
+ let mut local_require_confirmed_inputs_arg = if require_confirmed_inputs_arg.is_some() { Some( { () /*require_confirmed_inputs_arg.take()*/ }) } else { None };
+ OpenChannelV2 { inner: ObjOps::heap_alloc(nativeOpenChannelV2 {
+ common_fields: *unsafe { Box::from_raw(common_fields_arg.take_inner()) },
+ funding_feerate_sat_per_1000_weight: funding_feerate_sat_per_1000_weight_arg,
+ locktime: locktime_arg,
+ second_per_commitment_point: second_per_commitment_point_arg.into_rust(),
+ require_confirmed_inputs: local_require_confirmed_inputs_arg,
+ }), is_owned: true }
+}
+impl Clone for OpenChannelV2 {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeOpenChannelV2>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 OpenChannelV2_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeOpenChannelV2)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the OpenChannelV2
+pub extern "C" fn OpenChannelV2_clone(orig: &OpenChannelV2) -> OpenChannelV2 {
+ orig.clone()
+}
+/// Get a string which allows debug introspection of a OpenChannelV2 object
+pub extern "C" fn OpenChannelV2_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::OpenChannelV2 }).into()}
+/// Generates a non-cryptographic 64-bit hash of the OpenChannelV2.
+#[no_mangle]
+pub extern "C" fn OpenChannelV2_hash(o: &OpenChannelV2) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two OpenChannelV2s contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn OpenChannelV2_eq(a: &OpenChannelV2, b: &OpenChannelV2) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+
+use lightning::ln::msgs::CommonAcceptChannelFields as nativeCommonAcceptChannelFieldsImport;
+pub(crate) type nativeCommonAcceptChannelFields = nativeCommonAcceptChannelFieldsImport;
+
+/// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
+///
+/// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
+#[must_use]
+#[repr(C)]
+pub struct CommonAcceptChannelFields {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeCommonAcceptChannelFields,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for CommonAcceptChannelFields {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeCommonAcceptChannelFields>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the CommonAcceptChannelFields, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_free(this_obj: CommonAcceptChannelFields) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn CommonAcceptChannelFields_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeCommonAcceptChannelFields) };
+}
+#[allow(unused)]
+impl CommonAcceptChannelFields {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeCommonAcceptChannelFields {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeCommonAcceptChannelFields {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeCommonAcceptChannelFields {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_get_temporary_channel_id(this_ptr: &CommonAcceptChannelFields) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
+}
+/// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_set_temporary_channel_id(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The threshold below which outputs on transactions broadcast by the channel acceptor will be
+/// omitted
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_get_dust_limit_satoshis(this_ptr: &CommonAcceptChannelFields) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
+ *inner_val
+}
+/// The threshold below which outputs on transactions broadcast by the channel acceptor will be
+/// omitted
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: &OpenChannelV2) -> u64 {
+pub extern "C" fn CommonAcceptChannelFields_set_dust_limit_satoshis(this_ptr: &mut CommonAcceptChannelFields, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
+}
+/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_get_max_htlc_value_in_flight_msat(this_ptr: &CommonAcceptChannelFields) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().max_htlc_value_in_flight_msat;
*inner_val
}
-/// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
+/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: &mut OpenChannelV2, mut val: u64) {
+pub extern "C" fn CommonAcceptChannelFields_set_max_htlc_value_in_flight_msat(this_ptr: &mut CommonAcceptChannelFields, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_htlc_value_in_flight_msat = val;
}
-/// The minimum HTLC size incoming to channel initiator, in milli-satoshi
+/// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_htlc_minimum_msat(this_ptr: &OpenChannelV2) -> u64 {
+pub extern "C" fn CommonAcceptChannelFields_get_htlc_minimum_msat(this_ptr: &CommonAcceptChannelFields) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
*inner_val
}
-/// The minimum HTLC size incoming to channel initiator, in milli-satoshi
+/// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_htlc_minimum_msat(this_ptr: &mut OpenChannelV2, mut val: u64) {
+pub extern "C" fn CommonAcceptChannelFields_set_htlc_minimum_msat(this_ptr: &mut CommonAcceptChannelFields, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
}
+/// Minimum depth of the funding transaction before the channel is considered open
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_get_minimum_depth(this_ptr: &CommonAcceptChannelFields) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().minimum_depth;
+ *inner_val
+}
+/// Minimum depth of the funding transaction before the channel is considered open
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_set_minimum_depth(this_ptr: &mut CommonAcceptChannelFields, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.minimum_depth = val;
+}
/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
/// broadcast a commitment transaction
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_to_self_delay(this_ptr: &OpenChannelV2) -> u16 {
+pub extern "C" fn CommonAcceptChannelFields_get_to_self_delay(this_ptr: &CommonAcceptChannelFields) -> u16 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().to_self_delay;
*inner_val
}
/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
/// broadcast a commitment transaction
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_to_self_delay(this_ptr: &mut OpenChannelV2, mut val: u16) {
+pub extern "C" fn CommonAcceptChannelFields_set_to_self_delay(this_ptr: &mut CommonAcceptChannelFields, mut val: u16) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.to_self_delay = val;
}
-/// The maximum number of inbound HTLCs towards channel initiator
+/// The maximum number of inbound HTLCs towards channel acceptor
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_max_accepted_htlcs(this_ptr: &OpenChannelV2) -> u16 {
+pub extern "C" fn CommonAcceptChannelFields_get_max_accepted_htlcs(this_ptr: &CommonAcceptChannelFields) -> u16 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().max_accepted_htlcs;
*inner_val
}
-/// The maximum number of inbound HTLCs towards channel initiator
+/// The maximum number of inbound HTLCs towards channel acceptor
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_max_accepted_htlcs(this_ptr: &mut OpenChannelV2, mut val: u16) {
+pub extern "C" fn CommonAcceptChannelFields_set_max_accepted_htlcs(this_ptr: &mut CommonAcceptChannelFields, mut val: u16) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_accepted_htlcs = val;
}
-/// The locktime for the funding transaction
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_locktime(this_ptr: &OpenChannelV2) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().locktime;
- *inner_val
-}
-/// The locktime for the funding transaction
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_locktime(this_ptr: &mut OpenChannelV2, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.locktime = val;
-}
-/// The channel initiator's key controlling the funding transaction
+/// The channel acceptor's key controlling the funding transaction
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_funding_pubkey(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonAcceptChannelFields_get_funding_pubkey(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// The channel initiator's key controlling the funding transaction
+/// The channel acceptor's key controlling the funding transaction
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_funding_pubkey(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonAcceptChannelFields_set_funding_pubkey(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
}
/// Used to derive a revocation key for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_revocation_basepoint(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonAcceptChannelFields_get_revocation_basepoint(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().revocation_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
/// Used to derive a revocation key for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_revocation_basepoint(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonAcceptChannelFields_set_revocation_basepoint(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.revocation_basepoint = val.into_rust();
}
-/// A payment key to channel initiator for transactions broadcast by counterparty
+/// A payment key to channel acceptor for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_payment_basepoint(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonAcceptChannelFields_get_payment_basepoint(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// A payment key to channel initiator for transactions broadcast by counterparty
+/// A payment key to channel acceptor for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_payment_basepoint(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonAcceptChannelFields_set_payment_basepoint(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_basepoint = val.into_rust();
}
-/// Used to derive a payment key to channel initiator for transactions broadcast by channel
-/// initiator
+/// Used to derive a payment key to channel acceptor for transactions broadcast by channel
+/// acceptor
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_delayed_payment_basepoint(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonAcceptChannelFields_get_delayed_payment_basepoint(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().delayed_payment_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// Used to derive a payment key to channel initiator for transactions broadcast by channel
-/// initiator
+/// Used to derive a payment key to channel acceptor for transactions broadcast by channel
+/// acceptor
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_delayed_payment_basepoint(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonAcceptChannelFields_set_delayed_payment_basepoint(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.delayed_payment_basepoint = val.into_rust();
}
-/// Used to derive an HTLC payment key to channel initiator
+/// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_htlc_basepoint(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonAcceptChannelFields_get_htlc_basepoint(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_basepoint;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// Used to derive an HTLC payment key to channel initiator
+/// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_htlc_basepoint(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonAcceptChannelFields_set_htlc_basepoint(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_basepoint = val.into_rust();
}
-/// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
+/// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_first_per_commitment_point(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
+pub extern "C" fn CommonAcceptChannelFields_get_first_per_commitment_point(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::PublicKey {
let mut inner_val = &mut this_ptr.get_native_mut_ref().first_per_commitment_point;
crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
+/// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_first_per_commitment_point(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
+pub extern "C" fn CommonAcceptChannelFields_set_first_per_commitment_point(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::PublicKey) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_per_commitment_point = val.into_rust();
}
-/// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_second_per_commitment_point(this_ptr: &OpenChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().second_per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_second_per_commitment_point(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.second_per_commitment_point = val.into_rust();
-}
-/// Channel flags
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_channel_flags(this_ptr: &OpenChannelV2) -> u8 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_flags;
- *inner_val
-}
-/// Channel flags
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_channel_flags(this_ptr: &mut OpenChannelV2, mut val: u8) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_flags = val;
-}
-/// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
+/// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
/// collaboratively close
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_shutdown_scriptpubkey(this_ptr: &OpenChannelV2) -> crate::c_types::derived::COption_CVec_u8ZZ {
+pub extern "C" fn CommonAcceptChannelFields_get_shutdown_scriptpubkey(this_ptr: &CommonAcceptChannelFields) -> crate::c_types::derived::COption_CVec_u8ZZ {
let mut inner_val = &mut this_ptr.get_native_mut_ref().shutdown_scriptpubkey;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { (*inner_val.as_ref().unwrap()).clone().into_bytes().into() }) };
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { (*inner_val.as_ref().unwrap()).clone().to_bytes().into() }) };
local_inner_val
}
-/// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
+/// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
/// collaboratively close
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_shutdown_scriptpubkey(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ val_opt.take() }.into_rust()) }})} };
+pub extern "C" fn CommonAcceptChannelFields_set_shutdown_scriptpubkey(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
+ let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::ScriptBuf::from({ val_opt.take() }.into_rust()) }})} };
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.shutdown_scriptpubkey = local_val;
}
/// The channel type that this channel will represent. If none is set, we derive the channel
/// type from the intersection of our feature bits with our counterparty's feature bits from
/// the Init message.
///
+/// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
+/// [`CommonOpenChannelFields::channel_type`].
+///
/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_channel_type(this_ptr: &OpenChannelV2) -> crate::lightning::ln::features::ChannelTypeFeatures {
+pub extern "C" fn CommonAcceptChannelFields_get_channel_type(this_ptr: &CommonAcceptChannelFields) -> crate::lightning::ln::features::ChannelTypeFeatures {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_type;
let mut local_inner_val = crate::lightning::ln::features::ChannelTypeFeatures { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::features::ChannelTypeFeatures<>) as *mut _ }, is_owned: false };
local_inner_val
/// type from the intersection of our feature bits with our counterparty's feature bits from
/// the Init message.
///
+/// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
+/// [`CommonOpenChannelFields::channel_type`].
+///
/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_channel_type(this_ptr: &mut OpenChannelV2, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
+pub extern "C" fn CommonAcceptChannelFields_set_channel_type(this_ptr: &mut CommonAcceptChannelFields, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_type = local_val;
}
-/// Optionally, a requirement that only confirmed inputs can be added
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_get_require_confirmed_inputs(this_ptr: &OpenChannelV2) -> crate::c_types::derived::COption_NoneZ {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().require_confirmed_inputs;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NoneZ::None } else { crate::c_types::derived::COption_NoneZ::Some /* { () /**/ } */ };
- local_inner_val
-}
-/// Optionally, a requirement that only confirmed inputs can be added
-#[no_mangle]
-pub extern "C" fn OpenChannelV2_set_require_confirmed_inputs(this_ptr: &mut OpenChannelV2, mut val: crate::c_types::derived::COption_NoneZ) {
- let mut local_val = if val.is_some() { Some( { () /*val.take()*/ }) } else { None };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.require_confirmed_inputs = local_val;
-}
-/// Constructs a new OpenChannelV2 given each field
+/// Constructs a new CommonAcceptChannelFields given each field
///
/// Note that channel_type_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
#[must_use]
#[no_mangle]
-pub extern "C" fn OpenChannelV2_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_feerate_sat_per_1000_weight_arg: u32, mut commitment_feerate_sat_per_1000_weight_arg: u32, mut funding_satoshis_arg: u64, mut dust_limit_satoshis_arg: u64, mut max_htlc_value_in_flight_msat_arg: u64, mut htlc_minimum_msat_arg: u64, mut to_self_delay_arg: u16, mut max_accepted_htlcs_arg: u16, mut locktime_arg: u32, mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_basepoint_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey, mut first_per_commitment_point_arg: crate::c_types::PublicKey, mut second_per_commitment_point_arg: crate::c_types::PublicKey, mut channel_flags_arg: u8, mut shutdown_scriptpubkey_arg: crate::c_types::derived::COption_CVec_u8ZZ, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures, mut require_confirmed_inputs_arg: crate::c_types::derived::COption_NoneZ) -> OpenChannelV2 {
- let mut local_shutdown_scriptpubkey_arg = { /*shutdown_scriptpubkey_arg*/ let shutdown_scriptpubkey_arg_opt = shutdown_scriptpubkey_arg; if shutdown_scriptpubkey_arg_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ shutdown_scriptpubkey_arg_opt.take() }.into_rust()) }})} };
+pub extern "C" fn CommonAcceptChannelFields_new(mut temporary_channel_id_arg: crate::lightning::ln::types::ChannelId, mut dust_limit_satoshis_arg: u64, mut max_htlc_value_in_flight_msat_arg: u64, mut htlc_minimum_msat_arg: u64, mut minimum_depth_arg: u32, mut to_self_delay_arg: u16, mut max_accepted_htlcs_arg: u16, mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_basepoint_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey, mut first_per_commitment_point_arg: crate::c_types::PublicKey, mut shutdown_scriptpubkey_arg: crate::c_types::derived::COption_CVec_u8ZZ, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures) -> CommonAcceptChannelFields {
+ let mut local_shutdown_scriptpubkey_arg = { /*shutdown_scriptpubkey_arg*/ let shutdown_scriptpubkey_arg_opt = shutdown_scriptpubkey_arg; if shutdown_scriptpubkey_arg_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::ScriptBuf::from({ shutdown_scriptpubkey_arg_opt.take() }.into_rust()) }})} };
let mut local_channel_type_arg = if channel_type_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_type_arg.take_inner()) } }) };
- let mut local_require_confirmed_inputs_arg = if require_confirmed_inputs_arg.is_some() { Some( { () /*require_confirmed_inputs_arg.take()*/ }) } else { None };
- OpenChannelV2 { inner: ObjOps::heap_alloc(nativeOpenChannelV2 {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
- temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_arg.data),
- funding_feerate_sat_per_1000_weight: funding_feerate_sat_per_1000_weight_arg,
- commitment_feerate_sat_per_1000_weight: commitment_feerate_sat_per_1000_weight_arg,
- funding_satoshis: funding_satoshis_arg,
+ CommonAcceptChannelFields { inner: ObjOps::heap_alloc(nativeCommonAcceptChannelFields {
+ temporary_channel_id: *unsafe { Box::from_raw(temporary_channel_id_arg.take_inner()) },
dust_limit_satoshis: dust_limit_satoshis_arg,
max_htlc_value_in_flight_msat: max_htlc_value_in_flight_msat_arg,
htlc_minimum_msat: htlc_minimum_msat_arg,
+ minimum_depth: minimum_depth_arg,
to_self_delay: to_self_delay_arg,
max_accepted_htlcs: max_accepted_htlcs_arg,
- locktime: locktime_arg,
funding_pubkey: funding_pubkey_arg.into_rust(),
revocation_basepoint: revocation_basepoint_arg.into_rust(),
payment_basepoint: payment_basepoint_arg.into_rust(),
delayed_payment_basepoint: delayed_payment_basepoint_arg.into_rust(),
htlc_basepoint: htlc_basepoint_arg.into_rust(),
first_per_commitment_point: first_per_commitment_point_arg.into_rust(),
- second_per_commitment_point: second_per_commitment_point_arg.into_rust(),
- channel_flags: channel_flags_arg,
shutdown_scriptpubkey: local_shutdown_scriptpubkey_arg,
channel_type: local_channel_type_arg,
- require_confirmed_inputs: local_require_confirmed_inputs_arg,
}), is_owned: true }
}
-impl Clone for OpenChannelV2 {
+impl Clone for CommonAcceptChannelFields {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeOpenChannelV2>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeCommonAcceptChannelFields>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 OpenChannelV2_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeOpenChannelV2)).clone() })) as *mut c_void
+pub(crate) extern "C" fn CommonAcceptChannelFields_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeCommonAcceptChannelFields)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the OpenChannelV2
-pub extern "C" fn OpenChannelV2_clone(orig: &OpenChannelV2) -> OpenChannelV2 {
+/// Creates a copy of the CommonAcceptChannelFields
+pub extern "C" fn CommonAcceptChannelFields_clone(orig: &CommonAcceptChannelFields) -> CommonAcceptChannelFields {
orig.clone()
}
-/// Checks if two OpenChannelV2s contain equal inner contents.
+/// Get a string which allows debug introspection of a CommonAcceptChannelFields object
+pub extern "C" fn CommonAcceptChannelFields_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::CommonAcceptChannelFields }).into()}
+/// Generates a non-cryptographic 64-bit hash of the CommonAcceptChannelFields.
+#[no_mangle]
+pub extern "C" fn CommonAcceptChannelFields_hash(o: &CommonAcceptChannelFields) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two CommonAcceptChannelFieldss contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn OpenChannelV2_eq(a: &OpenChannelV2, b: &OpenChannelV2) -> bool {
+pub extern "C" fn CommonAcceptChannelFields_eq(a: &CommonAcceptChannelFields, b: &CommonAcceptChannelFields) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
ret
}
}
-/// 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] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
- &inner_val.0
-}
-/// A temporary channel ID, until the funding outpoint is announced
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_temporary_channel_id(this_ptr: &mut AcceptChannel, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The threshold below which outputs on transactions broadcast by sender will be omitted
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_dust_limit_satoshis(this_ptr: &AcceptChannel) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
- *inner_val
-}
-/// The threshold below which outputs on transactions broadcast by sender will be omitted
+/// Common fields of `accept_channel(2)`-like messages
#[no_mangle]
-pub extern "C" fn AcceptChannel_set_dust_limit_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
-}
-/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: &AcceptChannel) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().max_htlc_value_in_flight_msat;
- *inner_val
+pub extern "C" fn AcceptChannel_get_common_fields(this_ptr: &AcceptChannel) -> crate::lightning::ln::msgs::CommonAcceptChannelFields {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().common_fields;
+ crate::lightning::ln::msgs::CommonAcceptChannelFields { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::CommonAcceptChannelFields<>) as *mut _) }, is_owned: false }
}
-/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
+/// Common fields of `accept_channel(2)`-like messages
#[no_mangle]
-pub extern "C" fn AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut AcceptChannel, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_htlc_value_in_flight_msat = val;
+pub extern "C" fn AcceptChannel_set_common_fields(this_ptr: &mut AcceptChannel, mut val: crate::lightning::ln::msgs::CommonAcceptChannelFields) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.common_fields = *unsafe { Box::from_raw(val.take_inner()) };
}
/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
#[no_mangle]
pub extern "C" fn AcceptChannel_set_channel_reserve_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_reserve_satoshis = val;
}
-/// The minimum HTLC size incoming to sender, in milli-satoshi
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_htlc_minimum_msat(this_ptr: &AcceptChannel) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
- *inner_val
-}
-/// The minimum HTLC size incoming to sender, in milli-satoshi
+/// Constructs a new AcceptChannel given each field
+#[must_use]
#[no_mangle]
-pub extern "C" fn AcceptChannel_set_htlc_minimum_msat(this_ptr: &mut AcceptChannel, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
+pub extern "C" fn AcceptChannel_new(mut common_fields_arg: crate::lightning::ln::msgs::CommonAcceptChannelFields, mut channel_reserve_satoshis_arg: u64) -> AcceptChannel {
+ AcceptChannel { inner: ObjOps::heap_alloc(nativeAcceptChannel {
+ common_fields: *unsafe { Box::from_raw(common_fields_arg.take_inner()) },
+ channel_reserve_satoshis: channel_reserve_satoshis_arg,
+ }), is_owned: true }
}
-/// Minimum depth of the funding transaction before the channel is considered open
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_minimum_depth(this_ptr: &AcceptChannel) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().minimum_depth;
- *inner_val
-}
-/// Minimum depth of the funding transaction before the channel is considered open
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_minimum_depth(this_ptr: &mut AcceptChannel, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.minimum_depth = val;
-}
-/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_to_self_delay(this_ptr: &AcceptChannel) -> u16 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().to_self_delay;
- *inner_val
-}
-/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_to_self_delay(this_ptr: &mut AcceptChannel, mut val: u16) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.to_self_delay = val;
-}
-/// The maximum number of inbound HTLCs towards sender
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_max_accepted_htlcs(this_ptr: &AcceptChannel) -> u16 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().max_accepted_htlcs;
- *inner_val
-}
-/// The maximum number of inbound HTLCs towards sender
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_max_accepted_htlcs(this_ptr: &mut AcceptChannel, mut val: u16) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_accepted_htlcs = val;
-}
-/// The sender's key controlling the funding transaction
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_funding_pubkey(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The sender's key controlling the funding transaction
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_funding_pubkey(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
-}
-/// Used to derive a revocation key for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_revocation_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().revocation_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// Used to derive a revocation key for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_revocation_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.revocation_basepoint = val.into_rust();
-}
-/// A payment key to sender for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_payment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// A payment key to sender for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_payment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_point = val.into_rust();
-}
-/// Used to derive a payment key to sender for transactions broadcast by sender
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_delayed_payment_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().delayed_payment_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// Used to derive a payment key to sender for transactions broadcast by sender
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_delayed_payment_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.delayed_payment_basepoint = val.into_rust();
-}
-/// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_htlc_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_htlc_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_basepoint = val.into_rust();
-}
-/// The first to-be-broadcast-by-sender transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_first_per_commitment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().first_per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The first to-be-broadcast-by-sender transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_first_per_commitment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_per_commitment_point = val.into_rust();
-}
-/// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_shutdown_scriptpubkey(this_ptr: &AcceptChannel) -> crate::c_types::derived::COption_CVec_u8ZZ {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().shutdown_scriptpubkey;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { (*inner_val.as_ref().unwrap()).clone().into_bytes().into() }) };
- local_inner_val
-}
-/// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_shutdown_scriptpubkey(this_ptr: &mut AcceptChannel, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ val_opt.take() }.into_rust()) }})} };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.shutdown_scriptpubkey = local_val;
-}
-/// The channel type that this channel will represent.
-///
-/// If this is `None`, we derive the channel type from the intersection of
-/// our feature bits with our counterparty's feature bits from the [`Init`] message.
-/// This is required to match the equivalent field in [`OpenChannel::channel_type`].
-///
-/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[no_mangle]
-pub extern "C" fn AcceptChannel_get_channel_type(this_ptr: &AcceptChannel) -> crate::lightning::ln::features::ChannelTypeFeatures {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_type;
- let mut local_inner_val = crate::lightning::ln::features::ChannelTypeFeatures { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::features::ChannelTypeFeatures<>) as *mut _ }, is_owned: false };
- local_inner_val
-}
-/// The channel type that this channel will represent.
-///
-/// If this is `None`, we derive the channel type from the intersection of
-/// our feature bits with our counterparty's feature bits from the [`Init`] message.
-/// This is required to match the equivalent field in [`OpenChannel::channel_type`].
-///
-/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[no_mangle]
-pub extern "C" fn AcceptChannel_set_channel_type(this_ptr: &mut AcceptChannel, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
- let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_type = local_val;
-}
-/// Constructs a new AcceptChannel given each field
-///
-/// Note that channel_type_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[must_use]
-#[no_mangle]
-pub extern "C" fn AcceptChannel_new(mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut dust_limit_satoshis_arg: u64, mut max_htlc_value_in_flight_msat_arg: u64, mut channel_reserve_satoshis_arg: u64, mut htlc_minimum_msat_arg: u64, mut minimum_depth_arg: u32, mut to_self_delay_arg: u16, mut max_accepted_htlcs_arg: u16, mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_point_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey, mut first_per_commitment_point_arg: crate::c_types::PublicKey, mut shutdown_scriptpubkey_arg: crate::c_types::derived::COption_CVec_u8ZZ, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures) -> AcceptChannel {
- let mut local_shutdown_scriptpubkey_arg = { /*shutdown_scriptpubkey_arg*/ let shutdown_scriptpubkey_arg_opt = shutdown_scriptpubkey_arg; if shutdown_scriptpubkey_arg_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ shutdown_scriptpubkey_arg_opt.take() }.into_rust()) }})} };
- let mut local_channel_type_arg = if channel_type_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_type_arg.take_inner()) } }) };
- AcceptChannel { inner: ObjOps::heap_alloc(nativeAcceptChannel {
- temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_arg.data),
- dust_limit_satoshis: dust_limit_satoshis_arg,
- max_htlc_value_in_flight_msat: max_htlc_value_in_flight_msat_arg,
- channel_reserve_satoshis: channel_reserve_satoshis_arg,
- htlc_minimum_msat: htlc_minimum_msat_arg,
- minimum_depth: minimum_depth_arg,
- to_self_delay: to_self_delay_arg,
- max_accepted_htlcs: max_accepted_htlcs_arg,
- funding_pubkey: funding_pubkey_arg.into_rust(),
- revocation_basepoint: revocation_basepoint_arg.into_rust(),
- payment_point: payment_point_arg.into_rust(),
- delayed_payment_basepoint: delayed_payment_basepoint_arg.into_rust(),
- htlc_basepoint: htlc_basepoint_arg.into_rust(),
- first_per_commitment_point: first_per_commitment_point_arg.into_rust(),
- shutdown_scriptpubkey: local_shutdown_scriptpubkey_arg,
- channel_type: local_channel_type_arg,
- }), is_owned: true }
-}
-impl Clone for AcceptChannel {
- fn clone(&self) -> Self {
- Self {
- inner: if <*mut nativeAcceptChannel>::is_null(self.inner) { core::ptr::null_mut() } else {
- ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
- is_owned: true,
- }
- }
+impl Clone for AcceptChannel {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeAcceptChannel>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 extern "C" fn AcceptChannel_clone(orig: &AcceptChannel) -> AcceptChannel {
orig.clone()
}
+/// Get a string which allows debug introspection of a AcceptChannel object
+pub extern "C" fn AcceptChannel_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::AcceptChannel }).into()}
+/// Generates a non-cryptographic 64-bit hash of the AcceptChannel.
+#[no_mangle]
+pub extern "C" fn AcceptChannel_hash(o: &AcceptChannel) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two AcceptChannels contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
ret
}
}
-/// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
+/// Common fields of `accept_channel(2)`-like messages
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_temporary_channel_id(this_ptr: &AcceptChannelV2) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
- &inner_val.0
+pub extern "C" fn AcceptChannelV2_get_common_fields(this_ptr: &AcceptChannelV2) -> crate::lightning::ln::msgs::CommonAcceptChannelFields {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().common_fields;
+ crate::lightning::ln::msgs::CommonAcceptChannelFields { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::CommonAcceptChannelFields<>) as *mut _) }, is_owned: false }
}
-/// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
+/// Common fields of `accept_channel(2)`-like messages
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_temporary_channel_id(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn AcceptChannelV2_set_common_fields(this_ptr: &mut AcceptChannelV2, mut val: crate::lightning::ln::msgs::CommonAcceptChannelFields) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.common_fields = *unsafe { Box::from_raw(val.take_inner()) };
}
/// Part of the channel value contributed by the channel acceptor
#[no_mangle]
pub extern "C" fn AcceptChannelV2_set_funding_satoshis(this_ptr: &mut AcceptChannelV2, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_satoshis = val;
}
-/// The threshold below which outputs on transactions broadcast by the channel acceptor will be
-/// omitted
+/// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_dust_limit_satoshis(this_ptr: &AcceptChannelV2) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
- *inner_val
+pub extern "C" fn AcceptChannelV2_get_second_per_commitment_point(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().second_per_commitment_point;
+ crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// The threshold below which outputs on transactions broadcast by the channel acceptor will be
-/// omitted
+/// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_dust_limit_satoshis(this_ptr: &mut AcceptChannelV2, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
+pub extern "C" fn AcceptChannelV2_set_second_per_commitment_point(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.second_per_commitment_point = val.into_rust();
}
-/// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
+/// Optionally, a requirement that only confirmed inputs can be added
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: &AcceptChannelV2) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().max_htlc_value_in_flight_msat;
- *inner_val
+pub extern "C" fn AcceptChannelV2_get_require_confirmed_inputs(this_ptr: &AcceptChannelV2) -> crate::c_types::derived::COption_NoneZ {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().require_confirmed_inputs;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NoneZ::None } else { crate::c_types::derived::COption_NoneZ::Some /* { () /**/ } */ };
+ local_inner_val
}
-/// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
+/// Optionally, a requirement that only confirmed inputs can be added
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: &mut AcceptChannelV2, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_htlc_value_in_flight_msat = val;
+pub extern "C" fn AcceptChannelV2_set_require_confirmed_inputs(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::derived::COption_NoneZ) {
+ let mut local_val = if val.is_some() { Some( { () /*val.take()*/ }) } else { None };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.require_confirmed_inputs = local_val;
}
-/// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
+/// Constructs a new AcceptChannelV2 given each field
+#[must_use]
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_htlc_minimum_msat(this_ptr: &AcceptChannelV2) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
- *inner_val
+pub extern "C" fn AcceptChannelV2_new(mut common_fields_arg: crate::lightning::ln::msgs::CommonAcceptChannelFields, mut funding_satoshis_arg: u64, mut second_per_commitment_point_arg: crate::c_types::PublicKey, mut require_confirmed_inputs_arg: crate::c_types::derived::COption_NoneZ) -> AcceptChannelV2 {
+ let mut local_require_confirmed_inputs_arg = if require_confirmed_inputs_arg.is_some() { Some( { () /*require_confirmed_inputs_arg.take()*/ }) } else { None };
+ AcceptChannelV2 { inner: ObjOps::heap_alloc(nativeAcceptChannelV2 {
+ common_fields: *unsafe { Box::from_raw(common_fields_arg.take_inner()) },
+ funding_satoshis: funding_satoshis_arg,
+ second_per_commitment_point: second_per_commitment_point_arg.into_rust(),
+ require_confirmed_inputs: local_require_confirmed_inputs_arg,
+ }), is_owned: true }
}
-/// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_htlc_minimum_msat(this_ptr: &mut AcceptChannelV2, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
+impl Clone for AcceptChannelV2 {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeAcceptChannelV2>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 AcceptChannelV2_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeAcceptChannelV2)).clone() })) as *mut c_void
}
-/// Minimum depth of the funding transaction before the channel is considered open
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_minimum_depth(this_ptr: &AcceptChannelV2) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().minimum_depth;
- *inner_val
+/// Creates a copy of the AcceptChannelV2
+pub extern "C" fn AcceptChannelV2_clone(orig: &AcceptChannelV2) -> AcceptChannelV2 {
+ orig.clone()
}
-/// Minimum depth of the funding transaction before the channel is considered open
+/// Get a string which allows debug introspection of a AcceptChannelV2 object
+pub extern "C" fn AcceptChannelV2_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::AcceptChannelV2 }).into()}
+/// Generates a non-cryptographic 64-bit hash of the AcceptChannelV2.
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_minimum_depth(this_ptr: &mut AcceptChannelV2, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.minimum_depth = val;
+pub extern "C" fn AcceptChannelV2_hash(o: &AcceptChannelV2) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
}
-/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
-/// broadcast a commitment transaction
+/// Checks if two AcceptChannelV2s contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_to_self_delay(this_ptr: &AcceptChannelV2) -> u16 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().to_self_delay;
- *inner_val
+pub extern "C" fn AcceptChannelV2_eq(a: &AcceptChannelV2, b: &AcceptChannelV2) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
-/// broadcast a commitment transaction
+
+use lightning::ln::msgs::FundingCreated as nativeFundingCreatedImport;
+pub(crate) type nativeFundingCreated = nativeFundingCreatedImport;
+
+/// A [`funding_created`] message to be sent to or received from a peer.
+///
+/// Used in V1 channel establishment
+///
+/// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
+#[must_use]
+#[repr(C)]
+pub struct FundingCreated {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeFundingCreated,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for FundingCreated {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeFundingCreated>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the FundingCreated, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_to_self_delay(this_ptr: &mut AcceptChannelV2, mut val: u16) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.to_self_delay = val;
+pub extern "C" fn FundingCreated_free(this_obj: FundingCreated) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn FundingCreated_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeFundingCreated) };
}
-/// The maximum number of inbound HTLCs towards channel acceptor
+#[allow(unused)]
+impl FundingCreated {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeFundingCreated {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeFundingCreated {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeFundingCreated {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// A temporary channel ID, until the funding is established
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_max_accepted_htlcs(this_ptr: &AcceptChannelV2) -> u16 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().max_accepted_htlcs;
- *inner_val
+pub extern "C" fn FundingCreated_get_temporary_channel_id(this_ptr: &FundingCreated) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
-/// The maximum number of inbound HTLCs towards channel acceptor
+/// A temporary channel ID, until the funding is established
#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_max_accepted_htlcs(this_ptr: &mut AcceptChannelV2, mut val: u16) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_accepted_htlcs = val;
+pub extern "C" fn FundingCreated_set_temporary_channel_id(this_ptr: &mut FundingCreated, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The channel acceptor's key controlling the funding transaction
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_funding_pubkey(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The channel acceptor's key controlling the funding transaction
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_funding_pubkey(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
-}
-/// Used to derive a revocation key for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_revocation_basepoint(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().revocation_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// Used to derive a revocation key for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_revocation_basepoint(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.revocation_basepoint = val.into_rust();
-}
-/// A payment key to channel acceptor for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_payment_basepoint(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// A payment key to channel acceptor for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_payment_basepoint(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_basepoint = val.into_rust();
-}
-/// Used to derive a payment key to channel acceptor for transactions broadcast by channel
-/// acceptor
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_delayed_payment_basepoint(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().delayed_payment_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// Used to derive a payment key to channel acceptor for transactions broadcast by channel
-/// acceptor
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_delayed_payment_basepoint(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.delayed_payment_basepoint = val.into_rust();
-}
-/// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_htlc_basepoint(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_basepoint;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_htlc_basepoint(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_basepoint = val.into_rust();
-}
-/// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_first_per_commitment_point(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().first_per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_first_per_commitment_point(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_per_commitment_point = val.into_rust();
-}
-/// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_second_per_commitment_point(this_ptr: &AcceptChannelV2) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().second_per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_second_per_commitment_point(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.second_per_commitment_point = val.into_rust();
-}
-/// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
-/// collaboratively close
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr: &AcceptChannelV2) -> crate::c_types::derived::COption_CVec_u8ZZ {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().shutdown_scriptpubkey;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { (*inner_val.as_ref().unwrap()).clone().into_bytes().into() }) };
- local_inner_val
-}
-/// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
-/// collaboratively close
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ val_opt.take() }.into_rust()) }})} };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.shutdown_scriptpubkey = local_val;
-}
-/// The channel type that this channel will represent. If none is set, we derive the channel
-/// type from the intersection of our feature bits with our counterparty's feature bits from
-/// the Init message.
-///
-/// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
-///
-/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_channel_type(this_ptr: &AcceptChannelV2) -> crate::lightning::ln::features::ChannelTypeFeatures {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_type;
- let mut local_inner_val = crate::lightning::ln::features::ChannelTypeFeatures { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::features::ChannelTypeFeatures<>) as *mut _ }, is_owned: false };
- local_inner_val
-}
-/// The channel type that this channel will represent. If none is set, we derive the channel
-/// type from the intersection of our feature bits with our counterparty's feature bits from
-/// the Init message.
-///
-/// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
-///
-/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_channel_type(this_ptr: &mut AcceptChannelV2, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
- let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_type = local_val;
-}
-/// Optionally, a requirement that only confirmed inputs can be added
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_get_require_confirmed_inputs(this_ptr: &AcceptChannelV2) -> crate::c_types::derived::COption_NoneZ {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().require_confirmed_inputs;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NoneZ::None } else { crate::c_types::derived::COption_NoneZ::Some /* { () /**/ } */ };
- local_inner_val
-}
-/// Optionally, a requirement that only confirmed inputs can be added
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_set_require_confirmed_inputs(this_ptr: &mut AcceptChannelV2, mut val: crate::c_types::derived::COption_NoneZ) {
- let mut local_val = if val.is_some() { Some( { () /*val.take()*/ }) } else { None };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.require_confirmed_inputs = local_val;
-}
-/// Constructs a new AcceptChannelV2 given each field
-///
-/// Note that channel_type_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
-#[must_use]
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_new(mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_satoshis_arg: u64, mut dust_limit_satoshis_arg: u64, mut max_htlc_value_in_flight_msat_arg: u64, mut htlc_minimum_msat_arg: u64, mut minimum_depth_arg: u32, mut to_self_delay_arg: u16, mut max_accepted_htlcs_arg: u16, mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_basepoint_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey, mut first_per_commitment_point_arg: crate::c_types::PublicKey, mut second_per_commitment_point_arg: crate::c_types::PublicKey, mut shutdown_scriptpubkey_arg: crate::c_types::derived::COption_CVec_u8ZZ, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures, mut require_confirmed_inputs_arg: crate::c_types::derived::COption_NoneZ) -> AcceptChannelV2 {
- let mut local_shutdown_scriptpubkey_arg = { /*shutdown_scriptpubkey_arg*/ let shutdown_scriptpubkey_arg_opt = shutdown_scriptpubkey_arg; if shutdown_scriptpubkey_arg_opt.is_none() { None } else { Some({ { ::bitcoin::blockdata::script::Script::from({ shutdown_scriptpubkey_arg_opt.take() }.into_rust()) }})} };
- let mut local_channel_type_arg = if channel_type_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_type_arg.take_inner()) } }) };
- let mut local_require_confirmed_inputs_arg = if require_confirmed_inputs_arg.is_some() { Some( { () /*require_confirmed_inputs_arg.take()*/ }) } else { None };
- AcceptChannelV2 { inner: ObjOps::heap_alloc(nativeAcceptChannelV2 {
- temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_arg.data),
- funding_satoshis: funding_satoshis_arg,
- dust_limit_satoshis: dust_limit_satoshis_arg,
- max_htlc_value_in_flight_msat: max_htlc_value_in_flight_msat_arg,
- htlc_minimum_msat: htlc_minimum_msat_arg,
- minimum_depth: minimum_depth_arg,
- to_self_delay: to_self_delay_arg,
- max_accepted_htlcs: max_accepted_htlcs_arg,
- funding_pubkey: funding_pubkey_arg.into_rust(),
- revocation_basepoint: revocation_basepoint_arg.into_rust(),
- payment_basepoint: payment_basepoint_arg.into_rust(),
- delayed_payment_basepoint: delayed_payment_basepoint_arg.into_rust(),
- htlc_basepoint: htlc_basepoint_arg.into_rust(),
- first_per_commitment_point: first_per_commitment_point_arg.into_rust(),
- second_per_commitment_point: second_per_commitment_point_arg.into_rust(),
- shutdown_scriptpubkey: local_shutdown_scriptpubkey_arg,
- channel_type: local_channel_type_arg,
- require_confirmed_inputs: local_require_confirmed_inputs_arg,
- }), is_owned: true }
-}
-impl Clone for AcceptChannelV2 {
- fn clone(&self) -> Self {
- Self {
- inner: if <*mut nativeAcceptChannelV2>::is_null(self.inner) { core::ptr::null_mut() } else {
- ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 AcceptChannelV2_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeAcceptChannelV2)).clone() })) as *mut c_void
-}
-#[no_mangle]
-/// Creates a copy of the AcceptChannelV2
-pub extern "C" fn AcceptChannelV2_clone(orig: &AcceptChannelV2) -> AcceptChannelV2 {
- orig.clone()
-}
-/// Checks if two AcceptChannelV2s contain equal inner contents.
-/// This ignores pointers and is_owned flags and looks at the values in fields.
-/// Two objects with NULL inner values will be considered "equal" here.
-#[no_mangle]
-pub extern "C" fn AcceptChannelV2_eq(a: &AcceptChannelV2, b: &AcceptChannelV2) -> bool {
- if a.inner == b.inner { return true; }
- if a.inner.is_null() || b.inner.is_null() { return false; }
- if a.get_native_ref() == b.get_native_ref() { true } else { false }
-}
-
-use lightning::ln::msgs::FundingCreated as nativeFundingCreatedImport;
-pub(crate) type nativeFundingCreated = nativeFundingCreatedImport;
-
-/// A [`funding_created`] message to be sent to or received from a peer.
-///
-/// Used in V1 channel establishment
-///
-/// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
-#[must_use]
-#[repr(C)]
-pub struct FundingCreated {
- /// A pointer to the opaque Rust object.
-
- /// Nearly everywhere, inner must be non-null, however in places where
- /// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeFundingCreated,
- /// Indicates that this is the only struct which contains the same pointer.
-
- /// Rust functions which take ownership of an object provided via an argument require
- /// this to be true and invalidate the object pointed to by inner.
- pub is_owned: bool,
-}
-
-impl Drop for FundingCreated {
- fn drop(&mut self) {
- if self.is_owned && !<*mut nativeFundingCreated>::is_null(self.inner) {
- let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
- }
- }
-}
-/// Frees any resources used by the FundingCreated, if is_owned is set and inner is non-NULL.
-#[no_mangle]
-pub extern "C" fn FundingCreated_free(this_obj: FundingCreated) { }
-#[allow(unused)]
-/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn FundingCreated_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeFundingCreated) };
-}
-#[allow(unused)]
-impl FundingCreated {
- pub(crate) fn get_native_ref(&self) -> &'static nativeFundingCreated {
- unsafe { &*ObjOps::untweak_ptr(self.inner) }
- }
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeFundingCreated {
- unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
- }
- /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeFundingCreated {
- assert!(self.is_owned);
- let ret = ObjOps::untweak_ptr(self.inner);
- self.inner = core::ptr::null_mut();
- ret
- }
-}
-/// 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] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
- &inner_val.0
-}
-/// A temporary channel ID, until the funding is established
-#[no_mangle]
-pub extern "C" fn FundingCreated_set_temporary_channel_id(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The funding transaction ID
+/// The funding transaction ID
#[no_mangle]
pub extern "C" fn FundingCreated_get_funding_txid(this_ptr: &FundingCreated) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_txid;
- inner_val.as_inner()
+ inner_val.as_ref()
}
/// The funding transaction ID
#[no_mangle]
/// Constructs a new FundingCreated given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn FundingCreated_new(mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_txid_arg: crate::c_types::ThirtyTwoBytes, mut funding_output_index_arg: u16, mut signature_arg: crate::c_types::ECDSASignature) -> FundingCreated {
+pub extern "C" fn FundingCreated_new(mut temporary_channel_id_arg: crate::lightning::ln::types::ChannelId, mut funding_txid_arg: crate::c_types::ThirtyTwoBytes, mut funding_output_index_arg: u16, mut signature_arg: crate::c_types::ECDSASignature) -> FundingCreated {
FundingCreated { inner: ObjOps::heap_alloc(nativeFundingCreated {
- temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_arg.data),
+ temporary_channel_id: *unsafe { Box::from_raw(temporary_channel_id_arg.take_inner()) },
funding_txid: ::bitcoin::hash_types::Txid::from_slice(&funding_txid_arg.data[..]).unwrap(),
funding_output_index: funding_output_index_arg,
signature: signature_arg.into_rust(),
pub extern "C" fn FundingCreated_clone(orig: &FundingCreated) -> FundingCreated {
orig.clone()
}
+/// Get a string which allows debug introspection of a FundingCreated object
+pub extern "C" fn FundingCreated_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::FundingCreated }).into()}
+/// Generates a non-cryptographic 64-bit hash of the FundingCreated.
+#[no_mangle]
+pub extern "C" fn FundingCreated_hash(o: &FundingCreated) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two FundingCreateds contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn FundingSigned_get_channel_id(this_ptr: &FundingSigned) -> *const [u8; 32] {
+pub extern "C" fn FundingSigned_get_channel_id(this_ptr: &FundingSigned) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn FundingSigned_set_channel_id(this_ptr: &mut FundingSigned, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn FundingSigned_set_channel_id(this_ptr: &mut FundingSigned, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
/// The signature of the channel acceptor (fundee) on the initial commitment transaction
#[no_mangle]
/// Constructs a new FundingSigned given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn FundingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::ECDSASignature) -> FundingSigned {
+pub extern "C" fn FundingSigned_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut signature_arg: crate::c_types::ECDSASignature) -> FundingSigned {
FundingSigned { inner: ObjOps::heap_alloc(nativeFundingSigned {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
signature: signature_arg.into_rust(),
}), is_owned: true }
}
pub extern "C" fn FundingSigned_clone(orig: &FundingSigned) -> FundingSigned {
orig.clone()
}
+/// Get a string which allows debug introspection of a FundingSigned object
+pub extern "C" fn FundingSigned_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::FundingSigned }).into()}
+/// Generates a non-cryptographic 64-bit hash of the FundingSigned.
+#[no_mangle]
+pub extern "C" fn FundingSigned_hash(o: &FundingSigned) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two FundingSigneds contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn ChannelReady_get_channel_id(this_ptr: &ChannelReady) -> *const [u8; 32] {
+pub extern "C" fn ChannelReady_get_channel_id(this_ptr: &ChannelReady) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn ChannelReady_set_channel_id(this_ptr: &mut ChannelReady, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn ChannelReady_set_channel_id(this_ptr: &mut ChannelReady, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
/// The per-commitment point of the second commitment transaction
#[no_mangle]
/// Constructs a new ChannelReady given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn ChannelReady_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey, mut short_channel_id_alias_arg: crate::c_types::derived::COption_u64Z) -> ChannelReady {
+pub extern "C" fn ChannelReady_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut next_per_commitment_point_arg: crate::c_types::PublicKey, mut short_channel_id_alias_arg: crate::c_types::derived::COption_u64Z) -> ChannelReady {
let mut local_short_channel_id_alias_arg = if short_channel_id_alias_arg.is_some() { Some( { short_channel_id_alias_arg.take() }) } else { None };
ChannelReady { inner: ObjOps::heap_alloc(nativeChannelReady {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
short_channel_id_alias: local_short_channel_id_alias_arg,
}), is_owned: true }
pub extern "C" fn ChannelReady_clone(orig: &ChannelReady) -> ChannelReady {
orig.clone()
}
+/// Get a string which allows debug introspection of a ChannelReady object
+pub extern "C" fn ChannelReady_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ChannelReady }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ChannelReady.
+#[no_mangle]
+pub extern "C" fn ChannelReady_hash(o: &ChannelReady) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two ChannelReadys contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxAddInput as nativeTxAddInputImport;
-pub(crate) type nativeTxAddInput = nativeTxAddInputImport;
+use lightning::ln::msgs::Stfu as nativeStfuImport;
+pub(crate) type nativeStfu = nativeStfuImport;
-/// A tx_add_input message for adding an input during interactive transaction construction
-///
+/// An stfu (quiescence) message to be sent by or received from the stfu initiator.
#[must_use]
#[repr(C)]
-pub struct TxAddInput {
+pub struct Stfu {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxAddInput,
+ pub inner: *mut nativeStfu,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxAddInput {
+impl Drop for Stfu {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxAddInput>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeStfu>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxAddInput, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the Stfu, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxAddInput_free(this_obj: TxAddInput) { }
+pub extern "C" fn Stfu_free(this_obj: Stfu) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxAddInput_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAddInput) };
+pub(crate) extern "C" fn Stfu_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeStfu) };
}
#[allow(unused)]
-impl TxAddInput {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxAddInput {
+impl Stfu {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeStfu {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAddInput {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeStfu {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxAddInput {
+ pub(crate) fn take_inner(mut self) -> *mut nativeStfu {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// The channel ID
+/// The channel ID where quiescence is intended
#[no_mangle]
-pub extern "C" fn TxAddInput_get_channel_id(this_ptr: &TxAddInput) -> *const [u8; 32] {
+pub extern "C" fn Stfu_get_channel_id(this_ptr: &Stfu) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
-/// The channel ID
-#[no_mangle]
-pub extern "C" fn TxAddInput_set_channel_id(this_ptr: &mut TxAddInput, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// A randomly chosen unique identifier for this input, which is even for initiators and odd for
-/// non-initiators.
-#[no_mangle]
-pub extern "C" fn TxAddInput_get_serial_id(this_ptr: &TxAddInput) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
- *inner_val
-}
-/// A randomly chosen unique identifier for this input, which is even for initiators and odd for
-/// non-initiators.
-#[no_mangle]
-pub extern "C" fn TxAddInput_set_serial_id(this_ptr: &mut TxAddInput, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
-}
-/// Serialized transaction that contains the output this input spends to verify that it is non
-/// malleable.
-#[no_mangle]
-pub extern "C" fn TxAddInput_get_prevtx(this_ptr: &TxAddInput) -> crate::lightning::util::ser::TransactionU16LenLimited {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().prevtx;
- crate::lightning::util::ser::TransactionU16LenLimited { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::util::ser::TransactionU16LenLimited<>) as *mut _) }, is_owned: false }
-}
-/// Serialized transaction that contains the output this input spends to verify that it is non
-/// malleable.
-#[no_mangle]
-pub extern "C" fn TxAddInput_set_prevtx(this_ptr: &mut TxAddInput, mut val: crate::lightning::util::ser::TransactionU16LenLimited) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.prevtx = *unsafe { Box::from_raw(val.take_inner()) };
-}
-/// The index of the output being spent
-#[no_mangle]
-pub extern "C" fn TxAddInput_get_prevtx_out(this_ptr: &TxAddInput) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().prevtx_out;
- *inner_val
-}
-/// The index of the output being spent
+/// The channel ID where quiescence is intended
#[no_mangle]
-pub extern "C" fn TxAddInput_set_prevtx_out(this_ptr: &mut TxAddInput, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.prevtx_out = val;
+pub extern "C" fn Stfu_set_channel_id(this_ptr: &mut Stfu, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The sequence number of this input
+/// Initiator flag, 1 if initiating, 0 if replying to an stfu.
#[no_mangle]
-pub extern "C" fn TxAddInput_get_sequence(this_ptr: &TxAddInput) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().sequence;
+pub extern "C" fn Stfu_get_initiator(this_ptr: &Stfu) -> u8 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().initiator;
*inner_val
}
-/// The sequence number of this input
+/// Initiator flag, 1 if initiating, 0 if replying to an stfu.
#[no_mangle]
-pub extern "C" fn TxAddInput_set_sequence(this_ptr: &mut TxAddInput, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.sequence = val;
+pub extern "C" fn Stfu_set_initiator(this_ptr: &mut Stfu, mut val: u8) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.initiator = val;
}
-/// Constructs a new TxAddInput given each field
+/// Constructs a new Stfu given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxAddInput_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut serial_id_arg: u64, mut prevtx_arg: crate::lightning::util::ser::TransactionU16LenLimited, mut prevtx_out_arg: u32, mut sequence_arg: u32) -> TxAddInput {
- TxAddInput { inner: ObjOps::heap_alloc(nativeTxAddInput {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- serial_id: serial_id_arg,
- prevtx: *unsafe { Box::from_raw(prevtx_arg.take_inner()) },
- prevtx_out: prevtx_out_arg,
- sequence: sequence_arg,
+pub extern "C" fn Stfu_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut initiator_arg: u8) -> Stfu {
+ Stfu { inner: ObjOps::heap_alloc(nativeStfu {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ initiator: initiator_arg,
}), is_owned: true }
}
-impl Clone for TxAddInput {
+impl Clone for Stfu {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxAddInput>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeStfu>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxAddInput_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAddInput)).clone() })) as *mut c_void
+pub(crate) extern "C" fn Stfu_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeStfu)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxAddInput
-pub extern "C" fn TxAddInput_clone(orig: &TxAddInput) -> TxAddInput {
+/// Creates a copy of the Stfu
+pub extern "C" fn Stfu_clone(orig: &Stfu) -> Stfu {
orig.clone()
}
-/// Checks if two TxAddInputs contain equal inner contents.
+/// Get a string which allows debug introspection of a Stfu object
+pub extern "C" fn Stfu_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::Stfu }).into()}
+/// Checks if two Stfus contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxAddInput_eq(a: &TxAddInput, b: &TxAddInput) -> bool {
+pub extern "C" fn Stfu_eq(a: &Stfu, b: &Stfu) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxAddOutput as nativeTxAddOutputImport;
-pub(crate) type nativeTxAddOutput = nativeTxAddOutputImport;
+use lightning::ln::msgs::Splice as nativeSpliceImport;
+pub(crate) type nativeSplice = nativeSpliceImport;
-/// A tx_add_output message for adding an output during interactive transaction construction.
-///
+/// A splice message to be sent by or received from the stfu initiator (splice initiator).
#[must_use]
#[repr(C)]
-pub struct TxAddOutput {
+pub struct Splice {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxAddOutput,
+ pub inner: *mut nativeSplice,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxAddOutput {
+impl Drop for Splice {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxAddOutput>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeSplice>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxAddOutput, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the Splice, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxAddOutput_free(this_obj: TxAddOutput) { }
+pub extern "C" fn Splice_free(this_obj: Splice) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxAddOutput_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAddOutput) };
+pub(crate) extern "C" fn Splice_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSplice) };
}
#[allow(unused)]
-impl TxAddOutput {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxAddOutput {
+impl Splice {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeSplice {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAddOutput {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeSplice {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxAddOutput {
+ pub(crate) fn take_inner(mut self) -> *mut nativeSplice {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// The channel ID
+/// The channel ID where splicing is intended
#[no_mangle]
-pub extern "C" fn TxAddOutput_get_channel_id(this_ptr: &TxAddOutput) -> *const [u8; 32] {
+pub extern "C" fn Splice_get_channel_id(this_ptr: &Splice) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
-/// The channel ID
+/// The channel ID where splicing is intended
#[no_mangle]
-pub extern "C" fn TxAddOutput_set_channel_id(this_ptr: &mut TxAddOutput, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn Splice_set_channel_id(this_ptr: &mut Splice, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// A randomly chosen unique identifier for this output, which is even for initiators and odd for
-/// non-initiators.
+/// The genesis hash of the blockchain where the channel is intended to be spliced
#[no_mangle]
-pub extern "C" fn TxAddOutput_get_serial_id(this_ptr: &TxAddOutput) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
+pub extern "C" fn Splice_get_chain_hash(this_ptr: &Splice) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
+ inner_val.as_ref()
+}
+/// The genesis hash of the blockchain where the channel is intended to be spliced
+#[no_mangle]
+pub extern "C" fn Splice_set_chain_hash(this_ptr: &mut Splice, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
+}
+/// The intended change in channel capacity: the amount to be added (positive value)
+/// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
+#[no_mangle]
+pub extern "C" fn Splice_get_relative_satoshis(this_ptr: &Splice) -> i64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().relative_satoshis;
*inner_val
}
-/// A randomly chosen unique identifier for this output, which is even for initiators and odd for
-/// non-initiators.
+/// The intended change in channel capacity: the amount to be added (positive value)
+/// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
#[no_mangle]
-pub extern "C" fn TxAddOutput_set_serial_id(this_ptr: &mut TxAddOutput, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
+pub extern "C" fn Splice_set_relative_satoshis(this_ptr: &mut Splice, mut val: i64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.relative_satoshis = val;
}
-/// The satoshi value of the output
+/// The feerate for the new funding transaction, set by the splice initiator
#[no_mangle]
-pub extern "C" fn TxAddOutput_get_sats(this_ptr: &TxAddOutput) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().sats;
+pub extern "C" fn Splice_get_funding_feerate_perkw(this_ptr: &Splice) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_feerate_perkw;
*inner_val
}
-/// The satoshi value of the output
+/// The feerate for the new funding transaction, set by the splice initiator
#[no_mangle]
-pub extern "C" fn TxAddOutput_set_sats(this_ptr: &mut TxAddOutput, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.sats = val;
+pub extern "C" fn Splice_set_funding_feerate_perkw(this_ptr: &mut Splice, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_feerate_perkw = val;
}
-/// The scriptPubKey for the output
+/// The locktime for the new funding transaction
#[no_mangle]
-pub extern "C" fn TxAddOutput_get_script(this_ptr: &TxAddOutput) -> crate::c_types::u8slice {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().script;
- crate::c_types::u8slice::from_slice(&inner_val[..])
+pub extern "C" fn Splice_get_locktime(this_ptr: &Splice) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().locktime;
+ *inner_val
}
-/// The scriptPubKey for the output
+/// The locktime for the new funding transaction
#[no_mangle]
-pub extern "C" fn TxAddOutput_set_script(this_ptr: &mut TxAddOutput, mut val: crate::c_types::derived::CVec_u8Z) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.script = ::bitcoin::blockdata::script::Script::from(val.into_rust());
+pub extern "C" fn Splice_set_locktime(this_ptr: &mut Splice, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.locktime = val;
}
-/// Constructs a new TxAddOutput given each field
+/// The key of the sender (splice initiator) controlling the new funding transaction
+#[no_mangle]
+pub extern "C" fn Splice_get_funding_pubkey(this_ptr: &Splice) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
+ crate::c_types::PublicKey::from_rust(&inner_val)
+}
+/// The key of the sender (splice initiator) controlling the new funding transaction
+#[no_mangle]
+pub extern "C" fn Splice_set_funding_pubkey(this_ptr: &mut Splice, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
+}
+/// Constructs a new Splice given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxAddOutput_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut serial_id_arg: u64, mut sats_arg: u64, mut script_arg: crate::c_types::derived::CVec_u8Z) -> TxAddOutput {
- TxAddOutput { inner: ObjOps::heap_alloc(nativeTxAddOutput {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- serial_id: serial_id_arg,
- sats: sats_arg,
- script: ::bitcoin::blockdata::script::Script::from(script_arg.into_rust()),
+pub extern "C" fn Splice_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut relative_satoshis_arg: i64, mut funding_feerate_perkw_arg: u32, mut locktime_arg: u32, mut funding_pubkey_arg: crate::c_types::PublicKey) -> Splice {
+ Splice { inner: ObjOps::heap_alloc(nativeSplice {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
+ relative_satoshis: relative_satoshis_arg,
+ funding_feerate_perkw: funding_feerate_perkw_arg,
+ locktime: locktime_arg,
+ funding_pubkey: funding_pubkey_arg.into_rust(),
}), is_owned: true }
}
-impl Clone for TxAddOutput {
+impl Clone for Splice {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxAddOutput>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeSplice>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxAddOutput_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAddOutput)).clone() })) as *mut c_void
+pub(crate) extern "C" fn Splice_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeSplice)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxAddOutput
-pub extern "C" fn TxAddOutput_clone(orig: &TxAddOutput) -> TxAddOutput {
+/// Creates a copy of the Splice
+pub extern "C" fn Splice_clone(orig: &Splice) -> Splice {
orig.clone()
}
-/// Checks if two TxAddOutputs contain equal inner contents.
+/// Get a string which allows debug introspection of a Splice object
+pub extern "C" fn Splice_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::Splice }).into()}
+/// Checks if two Splices contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxAddOutput_eq(a: &TxAddOutput, b: &TxAddOutput) -> bool {
+pub extern "C" fn Splice_eq(a: &Splice, b: &Splice) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxRemoveInput as nativeTxRemoveInputImport;
-pub(crate) type nativeTxRemoveInput = nativeTxRemoveInputImport;
+use lightning::ln::msgs::SpliceAck as nativeSpliceAckImport;
+pub(crate) type nativeSpliceAck = nativeSpliceAckImport;
-/// A tx_remove_input message for removing an input during interactive transaction construction.
+/// A splice_ack message to be received by or sent to the splice initiator.
///
#[must_use]
#[repr(C)]
-pub struct TxRemoveInput {
+pub struct SpliceAck {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxRemoveInput,
+ pub inner: *mut nativeSpliceAck,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxRemoveInput {
+impl Drop for SpliceAck {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxRemoveInput>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeSpliceAck>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxRemoveInput, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the SpliceAck, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxRemoveInput_free(this_obj: TxRemoveInput) { }
+pub extern "C" fn SpliceAck_free(this_obj: SpliceAck) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxRemoveInput_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxRemoveInput) };
+pub(crate) extern "C" fn SpliceAck_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSpliceAck) };
}
#[allow(unused)]
-impl TxRemoveInput {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxRemoveInput {
+impl SpliceAck {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeSpliceAck {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxRemoveInput {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeSpliceAck {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxRemoveInput {
+ pub(crate) fn take_inner(mut self) -> *mut nativeSpliceAck {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// The channel ID
+/// The channel ID where splicing is intended
#[no_mangle]
-pub extern "C" fn TxRemoveInput_get_channel_id(this_ptr: &TxRemoveInput) -> *const [u8; 32] {
+pub extern "C" fn SpliceAck_get_channel_id(this_ptr: &SpliceAck) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
-/// The channel ID
+/// The channel ID where splicing is intended
#[no_mangle]
-pub extern "C" fn TxRemoveInput_set_channel_id(this_ptr: &mut TxRemoveInput, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn SpliceAck_set_channel_id(this_ptr: &mut SpliceAck, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The serial ID of the input to be removed
+/// The genesis hash of the blockchain where the channel is intended to be spliced
#[no_mangle]
-pub extern "C" fn TxRemoveInput_get_serial_id(this_ptr: &TxRemoveInput) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
+pub extern "C" fn SpliceAck_get_chain_hash(this_ptr: &SpliceAck) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
+ inner_val.as_ref()
+}
+/// The genesis hash of the blockchain where the channel is intended to be spliced
+#[no_mangle]
+pub extern "C" fn SpliceAck_set_chain_hash(this_ptr: &mut SpliceAck, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
+}
+/// The intended change in channel capacity: the amount to be added (positive value)
+/// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
+#[no_mangle]
+pub extern "C" fn SpliceAck_get_relative_satoshis(this_ptr: &SpliceAck) -> i64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().relative_satoshis;
*inner_val
}
-/// The serial ID of the input to be removed
+/// The intended change in channel capacity: the amount to be added (positive value)
+/// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
#[no_mangle]
-pub extern "C" fn TxRemoveInput_set_serial_id(this_ptr: &mut TxRemoveInput, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
+pub extern "C" fn SpliceAck_set_relative_satoshis(this_ptr: &mut SpliceAck, mut val: i64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.relative_satoshis = val;
}
-/// Constructs a new TxRemoveInput given each field
+/// The key of the sender (splice acceptor) controlling the new funding transaction
+#[no_mangle]
+pub extern "C" fn SpliceAck_get_funding_pubkey(this_ptr: &SpliceAck) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
+ crate::c_types::PublicKey::from_rust(&inner_val)
+}
+/// The key of the sender (splice acceptor) controlling the new funding transaction
+#[no_mangle]
+pub extern "C" fn SpliceAck_set_funding_pubkey(this_ptr: &mut SpliceAck, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
+}
+/// Constructs a new SpliceAck given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxRemoveInput_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut serial_id_arg: u64) -> TxRemoveInput {
- TxRemoveInput { inner: ObjOps::heap_alloc(nativeTxRemoveInput {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- serial_id: serial_id_arg,
+pub extern "C" fn SpliceAck_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut relative_satoshis_arg: i64, mut funding_pubkey_arg: crate::c_types::PublicKey) -> SpliceAck {
+ SpliceAck { inner: ObjOps::heap_alloc(nativeSpliceAck {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
+ relative_satoshis: relative_satoshis_arg,
+ funding_pubkey: funding_pubkey_arg.into_rust(),
}), is_owned: true }
}
-impl Clone for TxRemoveInput {
+impl Clone for SpliceAck {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxRemoveInput>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeSpliceAck>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxRemoveInput_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxRemoveInput)).clone() })) as *mut c_void
+pub(crate) extern "C" fn SpliceAck_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeSpliceAck)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxRemoveInput
-pub extern "C" fn TxRemoveInput_clone(orig: &TxRemoveInput) -> TxRemoveInput {
+/// Creates a copy of the SpliceAck
+pub extern "C" fn SpliceAck_clone(orig: &SpliceAck) -> SpliceAck {
orig.clone()
}
-/// Checks if two TxRemoveInputs contain equal inner contents.
+/// Get a string which allows debug introspection of a SpliceAck object
+pub extern "C" fn SpliceAck_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::SpliceAck }).into()}
+/// Checks if two SpliceAcks contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxRemoveInput_eq(a: &TxRemoveInput, b: &TxRemoveInput) -> bool {
+pub extern "C" fn SpliceAck_eq(a: &SpliceAck, b: &SpliceAck) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxRemoveOutput as nativeTxRemoveOutputImport;
-pub(crate) type nativeTxRemoveOutput = nativeTxRemoveOutputImport;
+use lightning::ln::msgs::SpliceLocked as nativeSpliceLockedImport;
+pub(crate) type nativeSpliceLocked = nativeSpliceLockedImport;
-/// A tx_remove_output message for removing an output during interactive transaction construction.
+/// A splice_locked message to be sent to or received from a peer.
///
#[must_use]
#[repr(C)]
-pub struct TxRemoveOutput {
+pub struct SpliceLocked {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxRemoveOutput,
+ pub inner: *mut nativeSpliceLocked,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxRemoveOutput {
+impl Drop for SpliceLocked {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxRemoveOutput>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeSpliceLocked>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxRemoveOutput, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the SpliceLocked, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxRemoveOutput_free(this_obj: TxRemoveOutput) { }
+pub extern "C" fn SpliceLocked_free(this_obj: SpliceLocked) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxRemoveOutput_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxRemoveOutput) };
+pub(crate) extern "C" fn SpliceLocked_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSpliceLocked) };
}
#[allow(unused)]
-impl TxRemoveOutput {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxRemoveOutput {
+impl SpliceLocked {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeSpliceLocked {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxRemoveOutput {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeSpliceLocked {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxRemoveOutput {
+ pub(crate) fn take_inner(mut self) -> *mut nativeSpliceLocked {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxRemoveOutput_get_channel_id(this_ptr: &TxRemoveOutput) -> *const [u8; 32] {
+pub extern "C" fn SpliceLocked_get_channel_id(this_ptr: &SpliceLocked) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxRemoveOutput_set_channel_id(this_ptr: &mut TxRemoveOutput, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The serial ID of the output to be removed
-#[no_mangle]
-pub extern "C" fn TxRemoveOutput_get_serial_id(this_ptr: &TxRemoveOutput) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
- *inner_val
-}
-/// The serial ID of the output to be removed
-#[no_mangle]
-pub extern "C" fn TxRemoveOutput_set_serial_id(this_ptr: &mut TxRemoveOutput, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
+pub extern "C" fn SpliceLocked_set_channel_id(this_ptr: &mut SpliceLocked, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// Constructs a new TxRemoveOutput given each field
+/// Constructs a new SpliceLocked given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxRemoveOutput_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut serial_id_arg: u64) -> TxRemoveOutput {
- TxRemoveOutput { inner: ObjOps::heap_alloc(nativeTxRemoveOutput {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- serial_id: serial_id_arg,
+pub extern "C" fn SpliceLocked_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId) -> SpliceLocked {
+ SpliceLocked { inner: ObjOps::heap_alloc(nativeSpliceLocked {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
}), is_owned: true }
}
-impl Clone for TxRemoveOutput {
+impl Clone for SpliceLocked {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxRemoveOutput>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeSpliceLocked>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxRemoveOutput_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxRemoveOutput)).clone() })) as *mut c_void
+pub(crate) extern "C" fn SpliceLocked_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeSpliceLocked)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxRemoveOutput
-pub extern "C" fn TxRemoveOutput_clone(orig: &TxRemoveOutput) -> TxRemoveOutput {
+/// Creates a copy of the SpliceLocked
+pub extern "C" fn SpliceLocked_clone(orig: &SpliceLocked) -> SpliceLocked {
orig.clone()
}
-/// Checks if two TxRemoveOutputs contain equal inner contents.
+/// Get a string which allows debug introspection of a SpliceLocked object
+pub extern "C" fn SpliceLocked_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::SpliceLocked }).into()}
+/// Checks if two SpliceLockeds contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxRemoveOutput_eq(a: &TxRemoveOutput, b: &TxRemoveOutput) -> bool {
+pub extern "C" fn SpliceLocked_eq(a: &SpliceLocked, b: &SpliceLocked) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxComplete as nativeTxCompleteImport;
-pub(crate) type nativeTxComplete = nativeTxCompleteImport;
+use lightning::ln::msgs::TxAddInput as nativeTxAddInputImport;
+pub(crate) type nativeTxAddInput = nativeTxAddInputImport;
-/// A tx_complete message signalling the conclusion of a peer's transaction contributions during
-/// interactive transaction construction.
+/// A tx_add_input message for adding an input during interactive transaction construction
///
#[must_use]
#[repr(C)]
-pub struct TxComplete {
+pub struct TxAddInput {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxComplete,
+ pub inner: *mut nativeTxAddInput,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxComplete {
+impl Drop for TxAddInput {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxComplete>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxAddInput>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxComplete, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxAddInput, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxComplete_free(this_obj: TxComplete) { }
+pub extern "C" fn TxAddInput_free(this_obj: TxAddInput) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxComplete_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxComplete) };
+pub(crate) extern "C" fn TxAddInput_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAddInput) };
}
#[allow(unused)]
-impl TxComplete {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxComplete {
+impl TxAddInput {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxAddInput {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxComplete {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAddInput {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxComplete {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxAddInput {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxComplete_get_channel_id(this_ptr: &TxComplete) -> *const [u8; 32] {
+pub extern "C" fn TxAddInput_get_channel_id(this_ptr: &TxAddInput) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxComplete_set_channel_id(this_ptr: &mut TxComplete, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn TxAddInput_set_channel_id(this_ptr: &mut TxAddInput, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// Constructs a new TxComplete given each field
-#[must_use]
+/// A randomly chosen unique identifier for this input, which is even for initiators and odd for
+/// non-initiators.
#[no_mangle]
-pub extern "C" fn TxComplete_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes) -> TxComplete {
- TxComplete { inner: ObjOps::heap_alloc(nativeTxComplete {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- }), is_owned: true }
+pub extern "C" fn TxAddInput_get_serial_id(this_ptr: &TxAddInput) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
+ *inner_val
}
-impl Clone for TxComplete {
- fn clone(&self) -> Self {
- Self {
- inner: if <*mut nativeTxComplete>::is_null(self.inner) { core::ptr::null_mut() } else {
- ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
+/// A randomly chosen unique identifier for this input, which is even for initiators and odd for
+/// non-initiators.
+#[no_mangle]
+pub extern "C" fn TxAddInput_set_serial_id(this_ptr: &mut TxAddInput, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
+}
+/// Serialized transaction that contains the output this input spends to verify that it is non
+/// malleable.
+#[no_mangle]
+pub extern "C" fn TxAddInput_get_prevtx(this_ptr: &TxAddInput) -> crate::lightning::util::ser::TransactionU16LenLimited {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().prevtx;
+ crate::lightning::util::ser::TransactionU16LenLimited { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::util::ser::TransactionU16LenLimited<>) as *mut _) }, is_owned: false }
+}
+/// Serialized transaction that contains the output this input spends to verify that it is non
+/// malleable.
+#[no_mangle]
+pub extern "C" fn TxAddInput_set_prevtx(this_ptr: &mut TxAddInput, mut val: crate::lightning::util::ser::TransactionU16LenLimited) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.prevtx = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The index of the output being spent
+#[no_mangle]
+pub extern "C" fn TxAddInput_get_prevtx_out(this_ptr: &TxAddInput) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().prevtx_out;
+ *inner_val
+}
+/// The index of the output being spent
+#[no_mangle]
+pub extern "C" fn TxAddInput_set_prevtx_out(this_ptr: &mut TxAddInput, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.prevtx_out = val;
+}
+/// The sequence number of this input
+#[no_mangle]
+pub extern "C" fn TxAddInput_get_sequence(this_ptr: &TxAddInput) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().sequence;
+ *inner_val
+}
+/// The sequence number of this input
+#[no_mangle]
+pub extern "C" fn TxAddInput_set_sequence(this_ptr: &mut TxAddInput, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.sequence = val;
+}
+/// Constructs a new TxAddInput given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn TxAddInput_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut serial_id_arg: u64, mut prevtx_arg: crate::lightning::util::ser::TransactionU16LenLimited, mut prevtx_out_arg: u32, mut sequence_arg: u32) -> TxAddInput {
+ TxAddInput { inner: ObjOps::heap_alloc(nativeTxAddInput {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ serial_id: serial_id_arg,
+ prevtx: *unsafe { Box::from_raw(prevtx_arg.take_inner()) },
+ prevtx_out: prevtx_out_arg,
+ sequence: sequence_arg,
+ }), is_owned: true }
+}
+impl Clone for TxAddInput {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeTxAddInput>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxComplete_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxComplete)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxAddInput_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAddInput)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxComplete
-pub extern "C" fn TxComplete_clone(orig: &TxComplete) -> TxComplete {
+/// Creates a copy of the TxAddInput
+pub extern "C" fn TxAddInput_clone(orig: &TxAddInput) -> TxAddInput {
orig.clone()
}
-/// Checks if two TxCompletes contain equal inner contents.
+/// Get a string which allows debug introspection of a TxAddInput object
+pub extern "C" fn TxAddInput_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxAddInput }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxAddInput.
+#[no_mangle]
+pub extern "C" fn TxAddInput_hash(o: &TxAddInput) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxAddInputs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxComplete_eq(a: &TxComplete, b: &TxComplete) -> bool {
+pub extern "C" fn TxAddInput_eq(a: &TxAddInput, b: &TxAddInput) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxSignatures as nativeTxSignaturesImport;
-pub(crate) type nativeTxSignatures = nativeTxSignaturesImport;
+use lightning::ln::msgs::TxAddOutput as nativeTxAddOutputImport;
+pub(crate) type nativeTxAddOutput = nativeTxAddOutputImport;
-/// A tx_signatures message containing the sender's signatures for a transaction constructed with
-/// interactive transaction construction.
+/// A tx_add_output message for adding an output during interactive transaction construction.
///
#[must_use]
#[repr(C)]
-pub struct TxSignatures {
+pub struct TxAddOutput {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxSignatures,
+ pub inner: *mut nativeTxAddOutput,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxSignatures {
+impl Drop for TxAddOutput {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxSignatures>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxAddOutput>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxSignatures, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxAddOutput, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxSignatures_free(this_obj: TxSignatures) { }
+pub extern "C" fn TxAddOutput_free(this_obj: TxAddOutput) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxSignatures_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxSignatures) };
+pub(crate) extern "C" fn TxAddOutput_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAddOutput) };
}
#[allow(unused)]
-impl TxSignatures {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxSignatures {
+impl TxAddOutput {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxAddOutput {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxSignatures {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAddOutput {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxSignatures {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxAddOutput {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxSignatures_get_channel_id(this_ptr: &TxSignatures) -> *const [u8; 32] {
+pub extern "C" fn TxAddOutput_get_channel_id(this_ptr: &TxAddOutput) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxSignatures_set_channel_id(this_ptr: &mut TxSignatures, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn TxAddOutput_set_channel_id(this_ptr: &mut TxAddOutput, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The TXID
+/// A randomly chosen unique identifier for this output, which is even for initiators and odd for
+/// non-initiators.
#[no_mangle]
-pub extern "C" fn TxSignatures_get_tx_hash(this_ptr: &TxSignatures) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().tx_hash;
- inner_val.as_inner()
+pub extern "C" fn TxAddOutput_get_serial_id(this_ptr: &TxAddOutput) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
+ *inner_val
}
-/// The TXID
+/// A randomly chosen unique identifier for this output, which is even for initiators and odd for
+/// non-initiators.
#[no_mangle]
-pub extern "C" fn TxSignatures_set_tx_hash(this_ptr: &mut TxSignatures, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.tx_hash = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap();
+pub extern "C" fn TxAddOutput_set_serial_id(this_ptr: &mut TxAddOutput, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
}
-/// The list of witnesses
-///
-/// Returns a copy of the field.
+/// The satoshi value of the output
#[no_mangle]
-pub extern "C" fn TxSignatures_get_witnesses(this_ptr: &TxSignatures) -> crate::c_types::derived::CVec_WitnessZ {
- let mut inner_val = this_ptr.get_native_mut_ref().witnesses.clone();
- let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { crate::c_types::Witness::from_bitcoin(&item) }); };
- local_inner_val.into()
+pub extern "C" fn TxAddOutput_get_sats(this_ptr: &TxAddOutput) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().sats;
+ *inner_val
}
-/// The list of witnesses
+/// The satoshi value of the output
#[no_mangle]
-pub extern "C" fn TxSignatures_set_witnesses(this_ptr: &mut TxSignatures, mut val: crate::c_types::derived::CVec_WitnessZ) {
- let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_bitcoin() }); };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.witnesses = local_val;
+pub extern "C" fn TxAddOutput_set_sats(this_ptr: &mut TxAddOutput, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.sats = val;
}
-/// Constructs a new TxSignatures given each field
+/// The scriptPubKey for the output
+#[no_mangle]
+pub extern "C" fn TxAddOutput_get_script(this_ptr: &TxAddOutput) -> crate::c_types::derived::CVec_u8Z {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().script;
+ inner_val.as_bytes().to_vec().into()
+}
+/// The scriptPubKey for the output
+#[no_mangle]
+pub extern "C" fn TxAddOutput_set_script(this_ptr: &mut TxAddOutput, mut val: crate::c_types::derived::CVec_u8Z) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.script = ::bitcoin::blockdata::script::ScriptBuf::from(val.into_rust());
+}
+/// Constructs a new TxAddOutput given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxSignatures_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut tx_hash_arg: crate::c_types::ThirtyTwoBytes, mut witnesses_arg: crate::c_types::derived::CVec_WitnessZ) -> TxSignatures {
- let mut local_witnesses_arg = Vec::new(); for mut item in witnesses_arg.into_rust().drain(..) { local_witnesses_arg.push( { item.into_bitcoin() }); };
- TxSignatures { inner: ObjOps::heap_alloc(nativeTxSignatures {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- tx_hash: ::bitcoin::hash_types::Txid::from_slice(&tx_hash_arg.data[..]).unwrap(),
- witnesses: local_witnesses_arg,
+pub extern "C" fn TxAddOutput_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut serial_id_arg: u64, mut sats_arg: u64, mut script_arg: crate::c_types::derived::CVec_u8Z) -> TxAddOutput {
+ TxAddOutput { inner: ObjOps::heap_alloc(nativeTxAddOutput {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ serial_id: serial_id_arg,
+ sats: sats_arg,
+ script: ::bitcoin::blockdata::script::ScriptBuf::from(script_arg.into_rust()),
}), is_owned: true }
}
-impl Clone for TxSignatures {
+impl Clone for TxAddOutput {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxSignatures>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxAddOutput>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxSignatures)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxAddOutput_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAddOutput)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxSignatures
-pub extern "C" fn TxSignatures_clone(orig: &TxSignatures) -> TxSignatures {
+/// Creates a copy of the TxAddOutput
+pub extern "C" fn TxAddOutput_clone(orig: &TxAddOutput) -> TxAddOutput {
orig.clone()
}
-/// Checks if two TxSignaturess contain equal inner contents.
+/// Get a string which allows debug introspection of a TxAddOutput object
+pub extern "C" fn TxAddOutput_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxAddOutput }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxAddOutput.
+#[no_mangle]
+pub extern "C" fn TxAddOutput_hash(o: &TxAddOutput) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxAddOutputs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxSignatures_eq(a: &TxSignatures, b: &TxSignatures) -> bool {
+pub extern "C" fn TxAddOutput_eq(a: &TxAddOutput, b: &TxAddOutput) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxInitRbf as nativeTxInitRbfImport;
-pub(crate) type nativeTxInitRbf = nativeTxInitRbfImport;
+use lightning::ln::msgs::TxRemoveInput as nativeTxRemoveInputImport;
+pub(crate) type nativeTxRemoveInput = nativeTxRemoveInputImport;
-/// A tx_init_rbf message which initiates a replacement of the transaction after it's been
-/// completed.
+/// A tx_remove_input message for removing an input during interactive transaction construction.
///
#[must_use]
#[repr(C)]
-pub struct TxInitRbf {
+pub struct TxRemoveInput {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxInitRbf,
+ pub inner: *mut nativeTxRemoveInput,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxInitRbf {
+impl Drop for TxRemoveInput {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxInitRbf>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxRemoveInput>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxInitRbf, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxRemoveInput, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxInitRbf_free(this_obj: TxInitRbf) { }
+pub extern "C" fn TxRemoveInput_free(this_obj: TxRemoveInput) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxInitRbf_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxInitRbf) };
+pub(crate) extern "C" fn TxRemoveInput_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxRemoveInput) };
}
#[allow(unused)]
-impl TxInitRbf {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxInitRbf {
+impl TxRemoveInput {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxRemoveInput {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxInitRbf {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxRemoveInput {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxInitRbf {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxRemoveInput {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxInitRbf_get_channel_id(this_ptr: &TxInitRbf) -> *const [u8; 32] {
+pub extern "C" fn TxRemoveInput_get_channel_id(this_ptr: &TxRemoveInput) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxInitRbf_set_channel_id(this_ptr: &mut TxInitRbf, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The locktime of the transaction
-#[no_mangle]
-pub extern "C" fn TxInitRbf_get_locktime(this_ptr: &TxInitRbf) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().locktime;
- *inner_val
-}
-/// The locktime of the transaction
-#[no_mangle]
-pub extern "C" fn TxInitRbf_set_locktime(this_ptr: &mut TxInitRbf, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.locktime = val;
+pub extern "C" fn TxRemoveInput_set_channel_id(this_ptr: &mut TxRemoveInput, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The feerate of the transaction
+/// The serial ID of the input to be removed
#[no_mangle]
-pub extern "C" fn TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: &TxInitRbf) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_sat_per_1000_weight;
+pub extern "C" fn TxRemoveInput_get_serial_id(this_ptr: &TxRemoveInput) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
*inner_val
}
-/// The feerate of the transaction
-#[no_mangle]
-pub extern "C" fn TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: &mut TxInitRbf, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_sat_per_1000_weight = val;
-}
-/// The number of satoshis the sender will contribute to or, if negative, remove from
-/// (e.g. splice-out) the funding output of the transaction
-#[no_mangle]
-pub extern "C" fn TxInitRbf_get_funding_output_contribution(this_ptr: &TxInitRbf) -> crate::c_types::derived::COption_i64Z {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_output_contribution;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_i64Z::None } else { crate::c_types::derived::COption_i64Z::Some( { inner_val.unwrap() }) };
- local_inner_val
-}
-/// The number of satoshis the sender will contribute to or, if negative, remove from
-/// (e.g. splice-out) the funding output of the transaction
+/// The serial ID of the input to be removed
#[no_mangle]
-pub extern "C" fn TxInitRbf_set_funding_output_contribution(this_ptr: &mut TxInitRbf, mut val: crate::c_types::derived::COption_i64Z) {
- let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_output_contribution = local_val;
+pub extern "C" fn TxRemoveInput_set_serial_id(this_ptr: &mut TxRemoveInput, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
}
-/// Constructs a new TxInitRbf given each field
+/// Constructs a new TxRemoveInput given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxInitRbf_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut locktime_arg: u32, mut feerate_sat_per_1000_weight_arg: u32, mut funding_output_contribution_arg: crate::c_types::derived::COption_i64Z) -> TxInitRbf {
- let mut local_funding_output_contribution_arg = if funding_output_contribution_arg.is_some() { Some( { funding_output_contribution_arg.take() }) } else { None };
- TxInitRbf { inner: ObjOps::heap_alloc(nativeTxInitRbf {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- locktime: locktime_arg,
- feerate_sat_per_1000_weight: feerate_sat_per_1000_weight_arg,
- funding_output_contribution: local_funding_output_contribution_arg,
+pub extern "C" fn TxRemoveInput_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut serial_id_arg: u64) -> TxRemoveInput {
+ TxRemoveInput { inner: ObjOps::heap_alloc(nativeTxRemoveInput {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ serial_id: serial_id_arg,
}), is_owned: true }
}
-impl Clone for TxInitRbf {
+impl Clone for TxRemoveInput {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxInitRbf>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxRemoveInput>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxInitRbf_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxInitRbf)).clone() })) as *mut c_void
-}
+pub(crate) extern "C" fn TxRemoveInput_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxRemoveInput)).clone() })) as *mut c_void
+}
#[no_mangle]
-/// Creates a copy of the TxInitRbf
-pub extern "C" fn TxInitRbf_clone(orig: &TxInitRbf) -> TxInitRbf {
+/// Creates a copy of the TxRemoveInput
+pub extern "C" fn TxRemoveInput_clone(orig: &TxRemoveInput) -> TxRemoveInput {
orig.clone()
}
-/// Checks if two TxInitRbfs contain equal inner contents.
+/// Get a string which allows debug introspection of a TxRemoveInput object
+pub extern "C" fn TxRemoveInput_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxRemoveInput }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxRemoveInput.
+#[no_mangle]
+pub extern "C" fn TxRemoveInput_hash(o: &TxRemoveInput) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxRemoveInputs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxInitRbf_eq(a: &TxInitRbf, b: &TxInitRbf) -> bool {
+pub extern "C" fn TxRemoveInput_eq(a: &TxRemoveInput, b: &TxRemoveInput) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxAckRbf as nativeTxAckRbfImport;
-pub(crate) type nativeTxAckRbf = nativeTxAckRbfImport;
+use lightning::ln::msgs::TxRemoveOutput as nativeTxRemoveOutputImport;
+pub(crate) type nativeTxRemoveOutput = nativeTxRemoveOutputImport;
-/// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
-/// completed.
+/// A tx_remove_output message for removing an output during interactive transaction construction.
///
#[must_use]
#[repr(C)]
-pub struct TxAckRbf {
+pub struct TxRemoveOutput {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxAckRbf,
+ pub inner: *mut nativeTxRemoveOutput,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxAckRbf {
+impl Drop for TxRemoveOutput {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxAckRbf>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxRemoveOutput>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxAckRbf, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxRemoveOutput, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxAckRbf_free(this_obj: TxAckRbf) { }
+pub extern "C" fn TxRemoveOutput_free(this_obj: TxRemoveOutput) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxAckRbf_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAckRbf) };
+pub(crate) extern "C" fn TxRemoveOutput_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxRemoveOutput) };
}
#[allow(unused)]
-impl TxAckRbf {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxAckRbf {
+impl TxRemoveOutput {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxRemoveOutput {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAckRbf {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxRemoveOutput {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxAckRbf {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxRemoveOutput {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxAckRbf_get_channel_id(this_ptr: &TxAckRbf) -> *const [u8; 32] {
+pub extern "C" fn TxRemoveOutput_get_channel_id(this_ptr: &TxRemoveOutput) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxAckRbf_set_channel_id(this_ptr: &mut TxAckRbf, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn TxRemoveOutput_set_channel_id(this_ptr: &mut TxRemoveOutput, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The number of satoshis the sender will contribute to or, if negative, remove from
-/// (e.g. splice-out) the funding output of the transaction
+/// The serial ID of the output to be removed
#[no_mangle]
-pub extern "C" fn TxAckRbf_get_funding_output_contribution(this_ptr: &TxAckRbf) -> crate::c_types::derived::COption_i64Z {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_output_contribution;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_i64Z::None } else { crate::c_types::derived::COption_i64Z::Some( { inner_val.unwrap() }) };
- local_inner_val
+pub extern "C" fn TxRemoveOutput_get_serial_id(this_ptr: &TxRemoveOutput) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().serial_id;
+ *inner_val
}
-/// The number of satoshis the sender will contribute to or, if negative, remove from
-/// (e.g. splice-out) the funding output of the transaction
+/// The serial ID of the output to be removed
#[no_mangle]
-pub extern "C" fn TxAckRbf_set_funding_output_contribution(this_ptr: &mut TxAckRbf, mut val: crate::c_types::derived::COption_i64Z) {
- let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_output_contribution = local_val;
+pub extern "C" fn TxRemoveOutput_set_serial_id(this_ptr: &mut TxRemoveOutput, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.serial_id = val;
}
-/// Constructs a new TxAckRbf given each field
+/// Constructs a new TxRemoveOutput given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxAckRbf_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_output_contribution_arg: crate::c_types::derived::COption_i64Z) -> TxAckRbf {
- let mut local_funding_output_contribution_arg = if funding_output_contribution_arg.is_some() { Some( { funding_output_contribution_arg.take() }) } else { None };
- TxAckRbf { inner: ObjOps::heap_alloc(nativeTxAckRbf {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- funding_output_contribution: local_funding_output_contribution_arg,
+pub extern "C" fn TxRemoveOutput_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut serial_id_arg: u64) -> TxRemoveOutput {
+ TxRemoveOutput { inner: ObjOps::heap_alloc(nativeTxRemoveOutput {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ serial_id: serial_id_arg,
}), is_owned: true }
}
-impl Clone for TxAckRbf {
+impl Clone for TxRemoveOutput {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxAckRbf>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxRemoveOutput>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxAckRbf_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAckRbf)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxRemoveOutput_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxRemoveOutput)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxAckRbf
-pub extern "C" fn TxAckRbf_clone(orig: &TxAckRbf) -> TxAckRbf {
+/// Creates a copy of the TxRemoveOutput
+pub extern "C" fn TxRemoveOutput_clone(orig: &TxRemoveOutput) -> TxRemoveOutput {
orig.clone()
}
-/// Checks if two TxAckRbfs contain equal inner contents.
+/// Get a string which allows debug introspection of a TxRemoveOutput object
+pub extern "C" fn TxRemoveOutput_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxRemoveOutput }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxRemoveOutput.
+#[no_mangle]
+pub extern "C" fn TxRemoveOutput_hash(o: &TxRemoveOutput) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxRemoveOutputs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxAckRbf_eq(a: &TxAckRbf, b: &TxAckRbf) -> bool {
+pub extern "C" fn TxRemoveOutput_eq(a: &TxRemoveOutput, b: &TxRemoveOutput) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::TxAbort as nativeTxAbortImport;
-pub(crate) type nativeTxAbort = nativeTxAbortImport;
+use lightning::ln::msgs::TxComplete as nativeTxCompleteImport;
+pub(crate) type nativeTxComplete = nativeTxCompleteImport;
-/// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
+/// A tx_complete message signalling the conclusion of a peer's transaction contributions during
+/// interactive transaction construction.
///
#[must_use]
#[repr(C)]
-pub struct TxAbort {
+pub struct TxComplete {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeTxAbort,
+ pub inner: *mut nativeTxComplete,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for TxAbort {
+impl Drop for TxComplete {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeTxAbort>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxComplete>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the TxAbort, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxComplete, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn TxAbort_free(this_obj: TxAbort) { }
+pub extern "C" fn TxComplete_free(this_obj: TxComplete) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn TxAbort_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAbort) };
+pub(crate) extern "C" fn TxComplete_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxComplete) };
}
#[allow(unused)]
-impl TxAbort {
- pub(crate) fn get_native_ref(&self) -> &'static nativeTxAbort {
+impl TxComplete {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxComplete {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAbort {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxComplete {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeTxAbort {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxComplete {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxAbort_get_channel_id(this_ptr: &TxAbort) -> *const [u8; 32] {
+pub extern "C" fn TxComplete_get_channel_id(this_ptr: &TxComplete) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn TxAbort_set_channel_id(this_ptr: &mut TxAbort, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// Message data
-///
-/// Returns a copy of the field.
-#[no_mangle]
-pub extern "C" fn TxAbort_get_data(this_ptr: &TxAbort) -> crate::c_types::derived::CVec_u8Z {
- let mut inner_val = this_ptr.get_native_mut_ref().data.clone();
- let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { item }); };
- local_inner_val.into()
-}
-/// Message data
-#[no_mangle]
-pub extern "C" fn TxAbort_set_data(this_ptr: &mut TxAbort, mut val: crate::c_types::derived::CVec_u8Z) {
- let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.data = local_val;
+pub extern "C" fn TxComplete_set_channel_id(this_ptr: &mut TxComplete, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// Constructs a new TxAbort given each field
+/// Constructs a new TxComplete given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn TxAbort_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::derived::CVec_u8Z) -> TxAbort {
- let mut local_data_arg = Vec::new(); for mut item in data_arg.into_rust().drain(..) { local_data_arg.push( { item }); };
- TxAbort { inner: ObjOps::heap_alloc(nativeTxAbort {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- data: local_data_arg,
+pub extern "C" fn TxComplete_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId) -> TxComplete {
+ TxComplete { inner: ObjOps::heap_alloc(nativeTxComplete {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
}), is_owned: true }
}
-impl Clone for TxAbort {
+impl Clone for TxComplete {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeTxAbort>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxComplete>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 TxAbort_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAbort)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxComplete_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxComplete)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the TxAbort
-pub extern "C" fn TxAbort_clone(orig: &TxAbort) -> TxAbort {
+/// Creates a copy of the TxComplete
+pub extern "C" fn TxComplete_clone(orig: &TxComplete) -> TxComplete {
orig.clone()
}
-/// Checks if two TxAborts contain equal inner contents.
+/// Get a string which allows debug introspection of a TxComplete object
+pub extern "C" fn TxComplete_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxComplete }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxComplete.
+#[no_mangle]
+pub extern "C" fn TxComplete_hash(o: &TxComplete) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxCompletes contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn TxAbort_eq(a: &TxAbort, b: &TxAbort) -> bool {
+pub extern "C" fn TxComplete_eq(a: &TxComplete, b: &TxComplete) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::Shutdown as nativeShutdownImport;
-pub(crate) type nativeShutdown = nativeShutdownImport;
+use lightning::ln::msgs::TxSignatures as nativeTxSignaturesImport;
+pub(crate) type nativeTxSignatures = nativeTxSignaturesImport;
-/// A [`shutdown`] message to be sent to or received from a peer.
+/// A tx_signatures message containing the sender's signatures for a transaction constructed with
+/// interactive transaction construction.
///
-/// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
#[must_use]
#[repr(C)]
-pub struct Shutdown {
+pub struct TxSignatures {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeShutdown,
+ pub inner: *mut nativeTxSignatures,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for Shutdown {
+impl Drop for TxSignatures {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeShutdown>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxSignatures>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the Shutdown, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxSignatures, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn Shutdown_free(this_obj: Shutdown) { }
+pub extern "C" fn TxSignatures_free(this_obj: TxSignatures) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn Shutdown_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeShutdown) };
+pub(crate) extern "C" fn TxSignatures_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxSignatures) };
}
#[allow(unused)]
-impl Shutdown {
- pub(crate) fn get_native_ref(&self) -> &'static nativeShutdown {
+impl TxSignatures {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxSignatures {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeShutdown {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxSignatures {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeShutdown {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxSignatures {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn Shutdown_get_channel_id(this_ptr: &Shutdown) -> *const [u8; 32] {
+pub extern "C" fn TxSignatures_get_channel_id(this_ptr: &TxSignatures) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn Shutdown_set_channel_id(this_ptr: &mut Shutdown, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn TxSignatures_set_channel_id(this_ptr: &mut TxSignatures, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The destination of this peer's funds on closing.
-///
-/// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
+/// The TXID
#[no_mangle]
-pub extern "C" fn Shutdown_get_scriptpubkey(this_ptr: &Shutdown) -> crate::c_types::u8slice {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().scriptpubkey;
- crate::c_types::u8slice::from_slice(&inner_val[..])
+pub extern "C" fn TxSignatures_get_tx_hash(this_ptr: &TxSignatures) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().tx_hash;
+ inner_val.as_ref()
}
-/// The destination of this peer's funds on closing.
+/// The TXID
+#[no_mangle]
+pub extern "C" fn TxSignatures_set_tx_hash(this_ptr: &mut TxSignatures, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.tx_hash = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap();
+}
+/// The list of witnesses
///
-/// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
+/// Returns a copy of the field.
#[no_mangle]
-pub extern "C" fn Shutdown_set_scriptpubkey(this_ptr: &mut Shutdown, mut val: crate::c_types::derived::CVec_u8Z) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.scriptpubkey = ::bitcoin::blockdata::script::Script::from(val.into_rust());
+pub extern "C" fn TxSignatures_get_witnesses(this_ptr: &TxSignatures) -> crate::c_types::derived::CVec_WitnessZ {
+ let mut inner_val = this_ptr.get_native_mut_ref().witnesses.clone();
+ let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { crate::c_types::Witness::from_bitcoin(&item) }); };
+ local_inner_val.into()
}
-/// Constructs a new Shutdown given each field
+/// The list of witnesses
+#[no_mangle]
+pub extern "C" fn TxSignatures_set_witnesses(this_ptr: &mut TxSignatures, mut val: crate::c_types::derived::CVec_WitnessZ) {
+ let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_bitcoin() }); };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.witnesses = local_val;
+}
+/// Optional signature for the shared input -- the previous funding outpoint -- signed by both peers
+#[no_mangle]
+pub extern "C" fn TxSignatures_get_funding_outpoint_sig(this_ptr: &TxSignatures) -> crate::c_types::derived::COption_ECDSASignatureZ {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_outpoint_sig;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_ECDSASignatureZ::None } else { crate::c_types::derived::COption_ECDSASignatureZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { crate::c_types::ECDSASignature::from_rust(&(*inner_val.as_ref().unwrap()).clone()) }) };
+ local_inner_val
+}
+/// Optional signature for the shared input -- the previous funding outpoint -- signed by both peers
+#[no_mangle]
+pub extern "C" fn TxSignatures_set_funding_outpoint_sig(this_ptr: &mut TxSignatures, mut val: crate::c_types::derived::COption_ECDSASignatureZ) {
+ let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { { val_opt.take() }.into_rust() }})} };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_outpoint_sig = local_val;
+}
+/// Constructs a new TxSignatures given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn Shutdown_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut scriptpubkey_arg: crate::c_types::derived::CVec_u8Z) -> Shutdown {
- Shutdown { inner: ObjOps::heap_alloc(nativeShutdown {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- scriptpubkey: ::bitcoin::blockdata::script::Script::from(scriptpubkey_arg.into_rust()),
+pub extern "C" fn TxSignatures_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut tx_hash_arg: crate::c_types::ThirtyTwoBytes, mut witnesses_arg: crate::c_types::derived::CVec_WitnessZ, mut funding_outpoint_sig_arg: crate::c_types::derived::COption_ECDSASignatureZ) -> TxSignatures {
+ let mut local_witnesses_arg = Vec::new(); for mut item in witnesses_arg.into_rust().drain(..) { local_witnesses_arg.push( { item.into_bitcoin() }); };
+ let mut local_funding_outpoint_sig_arg = { /*funding_outpoint_sig_arg*/ let funding_outpoint_sig_arg_opt = funding_outpoint_sig_arg; if funding_outpoint_sig_arg_opt.is_none() { None } else { Some({ { { funding_outpoint_sig_arg_opt.take() }.into_rust() }})} };
+ TxSignatures { inner: ObjOps::heap_alloc(nativeTxSignatures {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ tx_hash: ::bitcoin::hash_types::Txid::from_slice(&tx_hash_arg.data[..]).unwrap(),
+ witnesses: local_witnesses_arg,
+ funding_outpoint_sig: local_funding_outpoint_sig_arg,
}), is_owned: true }
}
-impl Clone for Shutdown {
+impl Clone for TxSignatures {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeShutdown>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxSignatures>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 Shutdown_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeShutdown)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxSignatures)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the Shutdown
-pub extern "C" fn Shutdown_clone(orig: &Shutdown) -> Shutdown {
+/// Creates a copy of the TxSignatures
+pub extern "C" fn TxSignatures_clone(orig: &TxSignatures) -> TxSignatures {
orig.clone()
}
-/// Checks if two Shutdowns contain equal inner contents.
+/// Get a string which allows debug introspection of a TxSignatures object
+pub extern "C" fn TxSignatures_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxSignatures }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxSignatures.
+#[no_mangle]
+pub extern "C" fn TxSignatures_hash(o: &TxSignatures) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxSignaturess contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn Shutdown_eq(a: &Shutdown, b: &Shutdown) -> bool {
+pub extern "C" fn TxSignatures_eq(a: &TxSignatures, b: &TxSignatures) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::ClosingSignedFeeRange as nativeClosingSignedFeeRangeImport;
-pub(crate) type nativeClosingSignedFeeRange = nativeClosingSignedFeeRangeImport;
+use lightning::ln::msgs::TxInitRbf as nativeTxInitRbfImport;
+pub(crate) type nativeTxInitRbf = nativeTxInitRbfImport;
-/// The minimum and maximum fees which the sender is willing to place on the closing transaction.
+/// A tx_init_rbf message which initiates a replacement of the transaction after it's been
+/// completed.
///
-/// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
-/// to use.
#[must_use]
#[repr(C)]
-pub struct ClosingSignedFeeRange {
+pub struct TxInitRbf {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeClosingSignedFeeRange,
+ pub inner: *mut nativeTxInitRbf,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for ClosingSignedFeeRange {
+impl Drop for TxInitRbf {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeClosingSignedFeeRange>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxInitRbf>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the ClosingSignedFeeRange, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxInitRbf, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_free(this_obj: ClosingSignedFeeRange) { }
+pub extern "C" fn TxInitRbf_free(this_obj: TxInitRbf) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn ClosingSignedFeeRange_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeClosingSignedFeeRange) };
+pub(crate) extern "C" fn TxInitRbf_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxInitRbf) };
}
#[allow(unused)]
-impl ClosingSignedFeeRange {
- pub(crate) fn get_native_ref(&self) -> &'static nativeClosingSignedFeeRange {
+impl TxInitRbf {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxInitRbf {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClosingSignedFeeRange {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxInitRbf {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeClosingSignedFeeRange {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxInitRbf {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
-/// transaction.
+/// The channel ID
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().min_fee_satoshis;
+pub extern "C" fn TxInitRbf_get_channel_id(this_ptr: &TxInitRbf) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn TxInitRbf_set_channel_id(this_ptr: &mut TxInitRbf, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The locktime of the transaction
+#[no_mangle]
+pub extern "C" fn TxInitRbf_get_locktime(this_ptr: &TxInitRbf) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().locktime;
*inner_val
}
-/// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
-/// transaction.
+/// The locktime of the transaction
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.min_fee_satoshis = val;
+pub extern "C" fn TxInitRbf_set_locktime(this_ptr: &mut TxInitRbf, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.locktime = val;
}
-/// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
-/// transaction.
+/// The feerate of the transaction
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().max_fee_satoshis;
+pub extern "C" fn TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: &TxInitRbf) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_sat_per_1000_weight;
*inner_val
}
-/// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
-/// transaction.
+/// The feerate of the transaction
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_fee_satoshis = val;
+pub extern "C" fn TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: &mut TxInitRbf, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_sat_per_1000_weight = val;
}
-/// Constructs a new ClosingSignedFeeRange given each field
+/// The number of satoshis the sender will contribute to or, if negative, remove from
+/// (e.g. splice-out) the funding output of the transaction
+#[no_mangle]
+pub extern "C" fn TxInitRbf_get_funding_output_contribution(this_ptr: &TxInitRbf) -> crate::c_types::derived::COption_i64Z {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_output_contribution;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_i64Z::None } else { crate::c_types::derived::COption_i64Z::Some( { inner_val.unwrap() }) };
+ local_inner_val
+}
+/// The number of satoshis the sender will contribute to or, if negative, remove from
+/// (e.g. splice-out) the funding output of the transaction
+#[no_mangle]
+pub extern "C" fn TxInitRbf_set_funding_output_contribution(this_ptr: &mut TxInitRbf, mut val: crate::c_types::derived::COption_i64Z) {
+ let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_output_contribution = local_val;
+}
+/// Constructs a new TxInitRbf given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_new(mut min_fee_satoshis_arg: u64, mut max_fee_satoshis_arg: u64) -> ClosingSignedFeeRange {
- ClosingSignedFeeRange { inner: ObjOps::heap_alloc(nativeClosingSignedFeeRange {
- min_fee_satoshis: min_fee_satoshis_arg,
- max_fee_satoshis: max_fee_satoshis_arg,
+pub extern "C" fn TxInitRbf_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut locktime_arg: u32, mut feerate_sat_per_1000_weight_arg: u32, mut funding_output_contribution_arg: crate::c_types::derived::COption_i64Z) -> TxInitRbf {
+ let mut local_funding_output_contribution_arg = if funding_output_contribution_arg.is_some() { Some( { funding_output_contribution_arg.take() }) } else { None };
+ TxInitRbf { inner: ObjOps::heap_alloc(nativeTxInitRbf {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ locktime: locktime_arg,
+ feerate_sat_per_1000_weight: feerate_sat_per_1000_weight_arg,
+ funding_output_contribution: local_funding_output_contribution_arg,
}), is_owned: true }
}
-impl Clone for ClosingSignedFeeRange {
+impl Clone for TxInitRbf {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeClosingSignedFeeRange>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxInitRbf>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 ClosingSignedFeeRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeClosingSignedFeeRange)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxInitRbf_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxInitRbf)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the ClosingSignedFeeRange
-pub extern "C" fn ClosingSignedFeeRange_clone(orig: &ClosingSignedFeeRange) -> ClosingSignedFeeRange {
+/// Creates a copy of the TxInitRbf
+pub extern "C" fn TxInitRbf_clone(orig: &TxInitRbf) -> TxInitRbf {
orig.clone()
}
-/// Checks if two ClosingSignedFeeRanges contain equal inner contents.
+/// Get a string which allows debug introspection of a TxInitRbf object
+pub extern "C" fn TxInitRbf_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxInitRbf }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxInitRbf.
+#[no_mangle]
+pub extern "C" fn TxInitRbf_hash(o: &TxInitRbf) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxInitRbfs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn ClosingSignedFeeRange_eq(a: &ClosingSignedFeeRange, b: &ClosingSignedFeeRange) -> bool {
+pub extern "C" fn TxInitRbf_eq(a: &TxInitRbf, b: &TxInitRbf) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::ClosingSigned as nativeClosingSignedImport;
-pub(crate) type nativeClosingSigned = nativeClosingSignedImport;
+use lightning::ln::msgs::TxAckRbf as nativeTxAckRbfImport;
+pub(crate) type nativeTxAckRbf = nativeTxAckRbfImport;
-/// A [`closing_signed`] message to be sent to or received from a peer.
+/// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
+/// completed.
///
-/// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
#[must_use]
#[repr(C)]
-pub struct ClosingSigned {
+pub struct TxAckRbf {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeClosingSigned,
+ pub inner: *mut nativeTxAckRbf,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for ClosingSigned {
+impl Drop for TxAckRbf {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeClosingSigned>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxAckRbf>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the ClosingSigned, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxAckRbf, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn ClosingSigned_free(this_obj: ClosingSigned) { }
+pub extern "C" fn TxAckRbf_free(this_obj: TxAckRbf) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn ClosingSigned_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeClosingSigned) };
+pub(crate) extern "C" fn TxAckRbf_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAckRbf) };
}
#[allow(unused)]
-impl ClosingSigned {
- pub(crate) fn get_native_ref(&self) -> &'static nativeClosingSigned {
+impl TxAckRbf {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxAckRbf {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClosingSigned {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAckRbf {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeClosingSigned {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxAckRbf {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn ClosingSigned_get_channel_id(this_ptr: &ClosingSigned) -> *const [u8; 32] {
+pub extern "C" fn TxAckRbf_get_channel_id(this_ptr: &TxAckRbf) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn ClosingSigned_set_channel_id(this_ptr: &mut ClosingSigned, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The proposed total fee for the closing transaction
-#[no_mangle]
-pub extern "C" fn ClosingSigned_get_fee_satoshis(this_ptr: &ClosingSigned) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_satoshis;
- *inner_val
-}
-/// The proposed total fee for the closing transaction
-#[no_mangle]
-pub extern "C" fn ClosingSigned_set_fee_satoshis(this_ptr: &mut ClosingSigned, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_satoshis = val;
-}
-/// A signature on the closing transaction
-#[no_mangle]
-pub extern "C" fn ClosingSigned_get_signature(this_ptr: &ClosingSigned) -> crate::c_types::ECDSASignature {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
- crate::c_types::ECDSASignature::from_rust(&inner_val)
-}
-/// A signature on the closing transaction
-#[no_mangle]
-pub extern "C" fn ClosingSigned_set_signature(this_ptr: &mut ClosingSigned, mut val: crate::c_types::ECDSASignature) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
+pub extern "C" fn TxAckRbf_set_channel_id(this_ptr: &mut TxAckRbf, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The minimum and maximum fees which the sender is willing to accept, provided only by new
-/// nodes.
-///
-/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+/// The number of satoshis the sender will contribute to or, if negative, remove from
+/// (e.g. splice-out) the funding output of the transaction
#[no_mangle]
-pub extern "C" fn ClosingSigned_get_fee_range(this_ptr: &ClosingSigned) -> crate::lightning::ln::msgs::ClosingSignedFeeRange {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_range;
- let mut local_inner_val = crate::lightning::ln::msgs::ClosingSignedFeeRange { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::msgs::ClosingSignedFeeRange<>) as *mut _ }, is_owned: false };
+pub extern "C" fn TxAckRbf_get_funding_output_contribution(this_ptr: &TxAckRbf) -> crate::c_types::derived::COption_i64Z {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_output_contribution;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_i64Z::None } else { crate::c_types::derived::COption_i64Z::Some( { inner_val.unwrap() }) };
local_inner_val
}
-/// The minimum and maximum fees which the sender is willing to accept, provided only by new
-/// nodes.
-///
-/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
+/// The number of satoshis the sender will contribute to or, if negative, remove from
+/// (e.g. splice-out) the funding output of the transaction
#[no_mangle]
-pub extern "C" fn ClosingSigned_set_fee_range(this_ptr: &mut ClosingSigned, mut val: crate::lightning::ln::msgs::ClosingSignedFeeRange) {
- let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_range = local_val;
+pub extern "C" fn TxAckRbf_set_funding_output_contribution(this_ptr: &mut TxAckRbf, mut val: crate::c_types::derived::COption_i64Z) {
+ let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_output_contribution = local_val;
}
-/// Constructs a new ClosingSigned given each field
-///
-/// Note that fee_range_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
+/// Constructs a new TxAckRbf given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn ClosingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut fee_satoshis_arg: u64, mut signature_arg: crate::c_types::ECDSASignature, mut fee_range_arg: crate::lightning::ln::msgs::ClosingSignedFeeRange) -> ClosingSigned {
- let mut local_fee_range_arg = if fee_range_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(fee_range_arg.take_inner()) } }) };
- ClosingSigned { inner: ObjOps::heap_alloc(nativeClosingSigned {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- fee_satoshis: fee_satoshis_arg,
- signature: signature_arg.into_rust(),
- fee_range: local_fee_range_arg,
+pub extern "C" fn TxAckRbf_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut funding_output_contribution_arg: crate::c_types::derived::COption_i64Z) -> TxAckRbf {
+ let mut local_funding_output_contribution_arg = if funding_output_contribution_arg.is_some() { Some( { funding_output_contribution_arg.take() }) } else { None };
+ TxAckRbf { inner: ObjOps::heap_alloc(nativeTxAckRbf {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ funding_output_contribution: local_funding_output_contribution_arg,
}), is_owned: true }
}
-impl Clone for ClosingSigned {
+impl Clone for TxAckRbf {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeClosingSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxAckRbf>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 ClosingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeClosingSigned)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxAckRbf_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAckRbf)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the ClosingSigned
-pub extern "C" fn ClosingSigned_clone(orig: &ClosingSigned) -> ClosingSigned {
+/// Creates a copy of the TxAckRbf
+pub extern "C" fn TxAckRbf_clone(orig: &TxAckRbf) -> TxAckRbf {
orig.clone()
}
-/// Checks if two ClosingSigneds contain equal inner contents.
+/// Get a string which allows debug introspection of a TxAckRbf object
+pub extern "C" fn TxAckRbf_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxAckRbf }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxAckRbf.
+#[no_mangle]
+pub extern "C" fn TxAckRbf_hash(o: &TxAckRbf) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxAckRbfs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn ClosingSigned_eq(a: &ClosingSigned, b: &ClosingSigned) -> bool {
+pub extern "C" fn TxAckRbf_eq(a: &TxAckRbf, b: &TxAckRbf) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::UpdateAddHTLC as nativeUpdateAddHTLCImport;
-pub(crate) type nativeUpdateAddHTLC = nativeUpdateAddHTLCImport;
+use lightning::ln::msgs::TxAbort as nativeTxAbortImport;
+pub(crate) type nativeTxAbort = nativeTxAbortImport;
-/// An [`update_add_htlc`] message to be sent to or received from a peer.
+/// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
///
-/// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
#[must_use]
#[repr(C)]
-pub struct UpdateAddHTLC {
+pub struct TxAbort {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeUpdateAddHTLC,
+ pub inner: *mut nativeTxAbort,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for UpdateAddHTLC {
+impl Drop for TxAbort {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeUpdateAddHTLC>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeTxAbort>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the UpdateAddHTLC, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the TxAbort, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_free(this_obj: UpdateAddHTLC) { }
+pub extern "C" fn TxAbort_free(this_obj: TxAbort) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn UpdateAddHTLC_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateAddHTLC) };
+pub(crate) extern "C" fn TxAbort_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTxAbort) };
}
#[allow(unused)]
-impl UpdateAddHTLC {
- pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateAddHTLC {
+impl TxAbort {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTxAbort {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateAddHTLC {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTxAbort {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeUpdateAddHTLC {
+ pub(crate) fn take_inner(mut self) -> *mut nativeTxAbort {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_get_channel_id(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
+pub extern "C" fn TxAbort_get_channel_id(this_ptr: &TxAbort) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_set_channel_id(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The HTLC ID
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_get_htlc_id(this_ptr: &UpdateAddHTLC) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
- *inner_val
+pub extern "C" fn TxAbort_set_channel_id(this_ptr: &mut TxAbort, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The HTLC ID
+/// Message data
+///
+/// Returns a copy of the field.
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_set_htlc_id(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
-}
-/// The HTLC value in milli-satoshi
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_get_amount_msat(this_ptr: &UpdateAddHTLC) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().amount_msat;
- *inner_val
-}
-/// The HTLC value in milli-satoshi
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_set_amount_msat(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.amount_msat = val;
-}
-/// The payment hash, the pre-image of which controls HTLC redemption
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_get_payment_hash(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_hash;
- &inner_val.0
-}
-/// The payment hash, the pre-image of which controls HTLC redemption
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_set_payment_hash(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_hash = ::lightning::ln::PaymentHash(val.data);
-}
-/// The expiry height of the HTLC
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_get_cltv_expiry(this_ptr: &UpdateAddHTLC) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry;
- *inner_val
-}
-/// The expiry height of the HTLC
-#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_set_cltv_expiry(this_ptr: &mut UpdateAddHTLC, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry = val;
+pub extern "C" fn TxAbort_get_data(this_ptr: &TxAbort) -> crate::c_types::derived::CVec_u8Z {
+ let mut inner_val = this_ptr.get_native_mut_ref().data.clone();
+ let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { item }); };
+ local_inner_val.into()
}
-/// The extra fee skimmed by the sender of this message. See
-/// [`ChannelConfig::accept_underpaying_htlcs`].
-///
-/// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
+/// Message data
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: &UpdateAddHTLC) -> crate::c_types::derived::COption_u64Z {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().skimmed_fee_msat;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { inner_val.unwrap() }) };
- local_inner_val
+pub extern "C" fn TxAbort_set_data(this_ptr: &mut TxAbort, mut val: crate::c_types::derived::CVec_u8Z) {
+ let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.data = local_val;
}
-/// The extra fee skimmed by the sender of this message. See
-/// [`ChannelConfig::accept_underpaying_htlcs`].
-///
-/// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
+/// Constructs a new TxAbort given each field
+#[must_use]
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::derived::COption_u64Z) {
- let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.skimmed_fee_msat = local_val;
+pub extern "C" fn TxAbort_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut data_arg: crate::c_types::derived::CVec_u8Z) -> TxAbort {
+ let mut local_data_arg = Vec::new(); for mut item in data_arg.into_rust().drain(..) { local_data_arg.push( { item }); };
+ TxAbort { inner: ObjOps::heap_alloc(nativeTxAbort {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ data: local_data_arg,
+ }), is_owned: true }
}
-impl Clone for UpdateAddHTLC {
+impl Clone for TxAbort {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeUpdateAddHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeTxAbort>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 UpdateAddHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUpdateAddHTLC)).clone() })) as *mut c_void
+pub(crate) extern "C" fn TxAbort_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTxAbort)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the UpdateAddHTLC
-pub extern "C" fn UpdateAddHTLC_clone(orig: &UpdateAddHTLC) -> UpdateAddHTLC {
+/// Creates a copy of the TxAbort
+pub extern "C" fn TxAbort_clone(orig: &TxAbort) -> TxAbort {
orig.clone()
}
-/// Checks if two UpdateAddHTLCs contain equal inner contents.
+/// Get a string which allows debug introspection of a TxAbort object
+pub extern "C" fn TxAbort_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TxAbort }).into()}
+/// Generates a non-cryptographic 64-bit hash of the TxAbort.
+#[no_mangle]
+pub extern "C" fn TxAbort_hash(o: &TxAbort) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TxAborts contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn UpdateAddHTLC_eq(a: &UpdateAddHTLC, b: &UpdateAddHTLC) -> bool {
+pub extern "C" fn TxAbort_eq(a: &TxAbort, b: &TxAbort) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::OnionMessage as nativeOnionMessageImport;
-pub(crate) type nativeOnionMessage = nativeOnionMessageImport;
+use lightning::ln::msgs::Shutdown as nativeShutdownImport;
+pub(crate) type nativeShutdown = nativeShutdownImport;
-/// An onion message to be sent to or received from a peer.
+/// A [`shutdown`] message to be sent to or received from a peer.
///
+/// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
#[must_use]
#[repr(C)]
-pub struct OnionMessage {
+pub struct Shutdown {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeOnionMessage,
+ pub inner: *mut nativeShutdown,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for OnionMessage {
+impl Drop for Shutdown {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeOnionMessage>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeShutdown>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the OnionMessage, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the Shutdown, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn OnionMessage_free(this_obj: OnionMessage) { }
+pub extern "C" fn Shutdown_free(this_obj: Shutdown) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn OnionMessage_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeOnionMessage) };
+pub(crate) extern "C" fn Shutdown_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeShutdown) };
}
#[allow(unused)]
-impl OnionMessage {
- pub(crate) fn get_native_ref(&self) -> &'static nativeOnionMessage {
+impl Shutdown {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeShutdown {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeOnionMessage {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeShutdown {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeOnionMessage {
+ pub(crate) fn take_inner(mut self) -> *mut nativeShutdown {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// Used in decrypting the onion packet's payload.
+/// The channel ID
#[no_mangle]
-pub extern "C" fn OnionMessage_get_blinding_point(this_ptr: &OnionMessage) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().blinding_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
+pub extern "C" fn Shutdown_get_channel_id(this_ptr: &Shutdown) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
-/// Used in decrypting the onion packet's payload.
+/// The channel ID
#[no_mangle]
-pub extern "C" fn OnionMessage_set_blinding_point(this_ptr: &mut OnionMessage, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.blinding_point = val.into_rust();
+pub extern "C" fn Shutdown_set_channel_id(this_ptr: &mut Shutdown, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The full onion packet including hop data, pubkey, and hmac
+/// The destination of this peer's funds on closing.
+///
+/// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
#[no_mangle]
-pub extern "C" fn OnionMessage_get_onion_routing_packet(this_ptr: &OnionMessage) -> crate::lightning::onion_message::packet::Packet {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().onion_routing_packet;
- crate::lightning::onion_message::packet::Packet { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::onion_message::packet::Packet<>) as *mut _) }, is_owned: false }
+pub extern "C" fn Shutdown_get_scriptpubkey(this_ptr: &Shutdown) -> crate::c_types::derived::CVec_u8Z {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().scriptpubkey;
+ inner_val.as_bytes().to_vec().into()
}
-/// The full onion packet including hop data, pubkey, and hmac
+/// The destination of this peer's funds on closing.
+///
+/// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
#[no_mangle]
-pub extern "C" fn OnionMessage_set_onion_routing_packet(this_ptr: &mut OnionMessage, mut val: crate::lightning::onion_message::packet::Packet) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.onion_routing_packet = *unsafe { Box::from_raw(val.take_inner()) };
+pub extern "C" fn Shutdown_set_scriptpubkey(this_ptr: &mut Shutdown, mut val: crate::c_types::derived::CVec_u8Z) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.scriptpubkey = ::bitcoin::blockdata::script::ScriptBuf::from(val.into_rust());
}
-/// Constructs a new OnionMessage given each field
+/// Constructs a new Shutdown given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn OnionMessage_new(mut blinding_point_arg: crate::c_types::PublicKey, mut onion_routing_packet_arg: crate::lightning::onion_message::packet::Packet) -> OnionMessage {
- OnionMessage { inner: ObjOps::heap_alloc(nativeOnionMessage {
- blinding_point: blinding_point_arg.into_rust(),
- onion_routing_packet: *unsafe { Box::from_raw(onion_routing_packet_arg.take_inner()) },
+pub extern "C" fn Shutdown_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut scriptpubkey_arg: crate::c_types::derived::CVec_u8Z) -> Shutdown {
+ Shutdown { inner: ObjOps::heap_alloc(nativeShutdown {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ scriptpubkey: ::bitcoin::blockdata::script::ScriptBuf::from(scriptpubkey_arg.into_rust()),
}), is_owned: true }
}
-impl Clone for OnionMessage {
+impl Clone for Shutdown {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeOnionMessage>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeShutdown>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 OnionMessage_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeOnionMessage)).clone() })) as *mut c_void
+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 *const nativeShutdown)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the OnionMessage
-pub extern "C" fn OnionMessage_clone(orig: &OnionMessage) -> OnionMessage {
+/// Creates a copy of the Shutdown
+pub extern "C" fn Shutdown_clone(orig: &Shutdown) -> Shutdown {
orig.clone()
}
-/// Checks if two OnionMessages contain equal inner contents.
+/// Get a string which allows debug introspection of a Shutdown object
+pub extern "C" fn Shutdown_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::Shutdown }).into()}
+/// Generates a non-cryptographic 64-bit hash of the Shutdown.
+#[no_mangle]
+pub extern "C" fn Shutdown_hash(o: &Shutdown) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two Shutdowns contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn OnionMessage_eq(a: &OnionMessage, b: &OnionMessage) -> bool {
+pub extern "C" fn Shutdown_eq(a: &Shutdown, b: &Shutdown) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::UpdateFulfillHTLC as nativeUpdateFulfillHTLCImport;
-pub(crate) type nativeUpdateFulfillHTLC = nativeUpdateFulfillHTLCImport;
+use lightning::ln::msgs::ClosingSignedFeeRange as nativeClosingSignedFeeRangeImport;
+pub(crate) type nativeClosingSignedFeeRange = nativeClosingSignedFeeRangeImport;
-/// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
+/// The minimum and maximum fees which the sender is willing to place on the closing transaction.
///
-/// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
+/// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
+/// to use.
#[must_use]
#[repr(C)]
-pub struct UpdateFulfillHTLC {
+pub struct ClosingSignedFeeRange {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeUpdateFulfillHTLC,
+ pub inner: *mut nativeClosingSignedFeeRange,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for UpdateFulfillHTLC {
+impl Drop for ClosingSignedFeeRange {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeUpdateFulfillHTLC>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeClosingSignedFeeRange>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the UpdateFulfillHTLC, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the ClosingSignedFeeRange, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_free(this_obj: UpdateFulfillHTLC) { }
+pub extern "C" fn ClosingSignedFeeRange_free(this_obj: ClosingSignedFeeRange) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn UpdateFulfillHTLC_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFulfillHTLC) };
+pub(crate) extern "C" fn ClosingSignedFeeRange_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeClosingSignedFeeRange) };
}
#[allow(unused)]
-impl UpdateFulfillHTLC {
- pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFulfillHTLC {
+impl ClosingSignedFeeRange {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeClosingSignedFeeRange {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFulfillHTLC {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClosingSignedFeeRange {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFulfillHTLC {
+ pub(crate) fn take_inner(mut self) -> *mut nativeClosingSignedFeeRange {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// The channel ID
-#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_get_channel_id(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
-}
-/// The channel ID
-#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_set_channel_id(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The HTLC ID
+/// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
+/// transaction.
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_get_htlc_id(this_ptr: &UpdateFulfillHTLC) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
+pub extern "C" fn ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().min_fee_satoshis;
*inner_val
}
-/// The HTLC ID
+/// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
+/// transaction.
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_set_htlc_id(this_ptr: &mut UpdateFulfillHTLC, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
+pub extern "C" fn ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.min_fee_satoshis = val;
}
-/// The pre-image of the payment hash, allowing HTLC redemption
+/// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
+/// transaction.
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_get_payment_preimage(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_preimage;
- &inner_val.0
+pub extern "C" fn ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().max_fee_satoshis;
+ *inner_val
}
-/// The pre-image of the payment hash, allowing HTLC redemption
+/// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
+/// transaction.
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_set_payment_preimage(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_preimage = ::lightning::ln::PaymentPreimage(val.data);
+pub extern "C" fn ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_fee_satoshis = val;
}
-/// Constructs a new UpdateFulfillHTLC given each field
+/// Constructs a new ClosingSignedFeeRange given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut htlc_id_arg: u64, mut payment_preimage_arg: crate::c_types::ThirtyTwoBytes) -> UpdateFulfillHTLC {
- UpdateFulfillHTLC { inner: ObjOps::heap_alloc(nativeUpdateFulfillHTLC {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- htlc_id: htlc_id_arg,
- payment_preimage: ::lightning::ln::PaymentPreimage(payment_preimage_arg.data),
+pub extern "C" fn ClosingSignedFeeRange_new(mut min_fee_satoshis_arg: u64, mut max_fee_satoshis_arg: u64) -> ClosingSignedFeeRange {
+ ClosingSignedFeeRange { inner: ObjOps::heap_alloc(nativeClosingSignedFeeRange {
+ min_fee_satoshis: min_fee_satoshis_arg,
+ max_fee_satoshis: max_fee_satoshis_arg,
}), is_owned: true }
}
-impl Clone for UpdateFulfillHTLC {
+impl Clone for ClosingSignedFeeRange {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeUpdateFulfillHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeClosingSignedFeeRange>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 UpdateFulfillHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUpdateFulfillHTLC)).clone() })) as *mut c_void
+pub(crate) extern "C" fn ClosingSignedFeeRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeClosingSignedFeeRange)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the UpdateFulfillHTLC
-pub extern "C" fn UpdateFulfillHTLC_clone(orig: &UpdateFulfillHTLC) -> UpdateFulfillHTLC {
+/// Creates a copy of the ClosingSignedFeeRange
+pub extern "C" fn ClosingSignedFeeRange_clone(orig: &ClosingSignedFeeRange) -> ClosingSignedFeeRange {
orig.clone()
}
-/// Checks if two UpdateFulfillHTLCs contain equal inner contents.
+/// Get a string which allows debug introspection of a ClosingSignedFeeRange object
+pub extern "C" fn ClosingSignedFeeRange_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ClosingSignedFeeRange }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ClosingSignedFeeRange.
+#[no_mangle]
+pub extern "C" fn ClosingSignedFeeRange_hash(o: &ClosingSignedFeeRange) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two ClosingSignedFeeRanges contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn UpdateFulfillHTLC_eq(a: &UpdateFulfillHTLC, b: &UpdateFulfillHTLC) -> bool {
+pub extern "C" fn ClosingSignedFeeRange_eq(a: &ClosingSignedFeeRange, b: &ClosingSignedFeeRange) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::UpdateFailHTLC as nativeUpdateFailHTLCImport;
-pub(crate) type nativeUpdateFailHTLC = nativeUpdateFailHTLCImport;
+use lightning::ln::msgs::ClosingSigned as nativeClosingSignedImport;
+pub(crate) type nativeClosingSigned = nativeClosingSignedImport;
-/// An [`update_fail_htlc`] message to be sent to or received from a peer.
+/// A [`closing_signed`] message to be sent to or received from a peer.
///
-/// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
+/// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
#[must_use]
#[repr(C)]
-pub struct UpdateFailHTLC {
+pub struct ClosingSigned {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeUpdateFailHTLC,
+ pub inner: *mut nativeClosingSigned,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for UpdateFailHTLC {
+impl Drop for ClosingSigned {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeUpdateFailHTLC>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeClosingSigned>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the UpdateFailHTLC, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the ClosingSigned, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn UpdateFailHTLC_free(this_obj: UpdateFailHTLC) { }
+pub extern "C" fn ClosingSigned_free(this_obj: ClosingSigned) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn UpdateFailHTLC_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFailHTLC) };
+pub(crate) extern "C" fn ClosingSigned_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeClosingSigned) };
}
#[allow(unused)]
-impl UpdateFailHTLC {
- pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFailHTLC {
+impl ClosingSigned {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeClosingSigned {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFailHTLC {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClosingSigned {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailHTLC {
+ pub(crate) fn take_inner(mut self) -> *mut nativeClosingSigned {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateFailHTLC_get_channel_id(this_ptr: &UpdateFailHTLC) -> *const [u8; 32] {
+pub extern "C" fn ClosingSigned_get_channel_id(this_ptr: &ClosingSigned) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateFailHTLC_set_channel_id(this_ptr: &mut UpdateFailHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn ClosingSigned_set_channel_id(this_ptr: &mut ClosingSigned, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The HTLC ID
+/// The proposed total fee for the closing transaction
#[no_mangle]
-pub extern "C" fn UpdateFailHTLC_get_htlc_id(this_ptr: &UpdateFailHTLC) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
+pub extern "C" fn ClosingSigned_get_fee_satoshis(this_ptr: &ClosingSigned) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_satoshis;
*inner_val
}
-/// The HTLC ID
+/// The proposed total fee for the closing transaction
#[no_mangle]
-pub extern "C" fn UpdateFailHTLC_set_htlc_id(this_ptr: &mut UpdateFailHTLC, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
+pub extern "C" fn ClosingSigned_set_fee_satoshis(this_ptr: &mut ClosingSigned, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_satoshis = val;
}
-impl Clone for UpdateFailHTLC {
+/// A signature on the closing transaction
+#[no_mangle]
+pub extern "C" fn ClosingSigned_get_signature(this_ptr: &ClosingSigned) -> crate::c_types::ECDSASignature {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
+ crate::c_types::ECDSASignature::from_rust(&inner_val)
+}
+/// A signature on the closing transaction
+#[no_mangle]
+pub extern "C" fn ClosingSigned_set_signature(this_ptr: &mut ClosingSigned, mut val: crate::c_types::ECDSASignature) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
+}
+/// The minimum and maximum fees which the sender is willing to accept, provided only by new
+/// nodes.
+///
+/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[no_mangle]
+pub extern "C" fn ClosingSigned_get_fee_range(this_ptr: &ClosingSigned) -> crate::lightning::ln::msgs::ClosingSignedFeeRange {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_range;
+ let mut local_inner_val = crate::lightning::ln::msgs::ClosingSignedFeeRange { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::msgs::ClosingSignedFeeRange<>) as *mut _ }, is_owned: false };
+ local_inner_val
+}
+/// The minimum and maximum fees which the sender is willing to accept, provided only by new
+/// nodes.
+///
+/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[no_mangle]
+pub extern "C" fn ClosingSigned_set_fee_range(this_ptr: &mut ClosingSigned, mut val: crate::lightning::ln::msgs::ClosingSignedFeeRange) {
+ let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_range = local_val;
+}
+/// Constructs a new ClosingSigned given each field
+///
+/// Note that fee_range_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[must_use]
+#[no_mangle]
+pub extern "C" fn ClosingSigned_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut fee_satoshis_arg: u64, mut signature_arg: crate::c_types::ECDSASignature, mut fee_range_arg: crate::lightning::ln::msgs::ClosingSignedFeeRange) -> ClosingSigned {
+ let mut local_fee_range_arg = if fee_range_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(fee_range_arg.take_inner()) } }) };
+ ClosingSigned { inner: ObjOps::heap_alloc(nativeClosingSigned {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ fee_satoshis: fee_satoshis_arg,
+ signature: signature_arg.into_rust(),
+ fee_range: local_fee_range_arg,
+ }), is_owned: true }
+}
+impl Clone for ClosingSigned {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeUpdateFailHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeClosingSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 UpdateFailHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUpdateFailHTLC)).clone() })) as *mut c_void
+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 *const nativeClosingSigned)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the UpdateFailHTLC
-pub extern "C" fn UpdateFailHTLC_clone(orig: &UpdateFailHTLC) -> UpdateFailHTLC {
+/// Creates a copy of the ClosingSigned
+pub extern "C" fn ClosingSigned_clone(orig: &ClosingSigned) -> ClosingSigned {
orig.clone()
}
-/// Checks if two UpdateFailHTLCs contain equal inner contents.
+/// Get a string which allows debug introspection of a ClosingSigned object
+pub extern "C" fn ClosingSigned_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ClosingSigned }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ClosingSigned.
+#[no_mangle]
+pub extern "C" fn ClosingSigned_hash(o: &ClosingSigned) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two ClosingSigneds contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn UpdateFailHTLC_eq(a: &UpdateFailHTLC, b: &UpdateFailHTLC) -> bool {
+pub extern "C" fn ClosingSigned_eq(a: &ClosingSigned, b: &ClosingSigned) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::UpdateFailMalformedHTLC as nativeUpdateFailMalformedHTLCImport;
-pub(crate) type nativeUpdateFailMalformedHTLC = nativeUpdateFailMalformedHTLCImport;
+use lightning::ln::msgs::UpdateAddHTLC as nativeUpdateAddHTLCImport;
+pub(crate) type nativeUpdateAddHTLC = nativeUpdateAddHTLCImport;
-/// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
+/// An [`update_add_htlc`] message to be sent to or received from a peer.
///
-/// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
+/// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
#[must_use]
#[repr(C)]
-pub struct UpdateFailMalformedHTLC {
+pub struct UpdateAddHTLC {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeUpdateFailMalformedHTLC,
+ pub inner: *mut nativeUpdateAddHTLC,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for UpdateFailMalformedHTLC {
+impl Drop for UpdateAddHTLC {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeUpdateAddHTLC>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the UpdateFailMalformedHTLC, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the UpdateAddHTLC, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_free(this_obj: UpdateFailMalformedHTLC) { }
+pub extern "C" fn UpdateAddHTLC_free(this_obj: UpdateAddHTLC) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn UpdateFailMalformedHTLC_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFailMalformedHTLC) };
+pub(crate) extern "C" fn UpdateAddHTLC_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateAddHTLC) };
}
#[allow(unused)]
-impl UpdateFailMalformedHTLC {
- pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFailMalformedHTLC {
+impl UpdateAddHTLC {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateAddHTLC {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFailMalformedHTLC {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateAddHTLC {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailMalformedHTLC {
+ pub(crate) fn take_inner(mut self) -> *mut nativeUpdateAddHTLC {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_get_channel_id(this_ptr: &UpdateFailMalformedHTLC) -> *const [u8; 32] {
+pub extern "C" fn UpdateAddHTLC_get_channel_id(this_ptr: &UpdateAddHTLC) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_set_channel_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn UpdateAddHTLC_set_channel_id(this_ptr: &mut UpdateAddHTLC, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
/// The HTLC ID
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_get_htlc_id(this_ptr: &UpdateFailMalformedHTLC) -> u64 {
+pub extern "C" fn UpdateAddHTLC_get_htlc_id(this_ptr: &UpdateAddHTLC) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
*inner_val
}
/// The HTLC ID
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_set_htlc_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u64) {
+pub extern "C" fn UpdateAddHTLC_set_htlc_id(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
}
-/// The failure code
+/// The HTLC value in milli-satoshi
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_get_failure_code(this_ptr: &UpdateFailMalformedHTLC) -> u16 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().failure_code;
+pub extern "C" fn UpdateAddHTLC_get_amount_msat(this_ptr: &UpdateAddHTLC) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().amount_msat;
*inner_val
}
-/// The failure code
+/// The HTLC value in milli-satoshi
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_set_failure_code(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u16) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.failure_code = val;
+pub extern "C" fn UpdateAddHTLC_set_amount_msat(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.amount_msat = val;
}
-impl Clone for UpdateFailMalformedHTLC {
+/// The payment hash, the pre-image of which controls HTLC redemption
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_get_payment_hash(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_hash;
+ &inner_val.0
+}
+/// The payment hash, the pre-image of which controls HTLC redemption
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_set_payment_hash(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_hash = ::lightning::ln::types::PaymentHash(val.data);
+}
+/// The expiry height of the HTLC
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_get_cltv_expiry(this_ptr: &UpdateAddHTLC) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry;
+ *inner_val
+}
+/// The expiry height of the HTLC
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_set_cltv_expiry(this_ptr: &mut UpdateAddHTLC, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry = val;
+}
+/// The extra fee skimmed by the sender of this message. See
+/// [`ChannelConfig::accept_underpaying_htlcs`].
+///
+/// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: &UpdateAddHTLC) -> crate::c_types::derived::COption_u64Z {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().skimmed_fee_msat;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { inner_val.unwrap() }) };
+ local_inner_val
+}
+/// The extra fee skimmed by the sender of this message. See
+/// [`ChannelConfig::accept_underpaying_htlcs`].
+///
+/// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::derived::COption_u64Z) {
+ let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.skimmed_fee_msat = local_val;
+}
+/// The onion routing packet with encrypted data for the next hop.
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_get_onion_routing_packet(this_ptr: &UpdateAddHTLC) -> crate::lightning::ln::msgs::OnionPacket {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().onion_routing_packet;
+ crate::lightning::ln::msgs::OnionPacket { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::OnionPacket<>) as *mut _) }, is_owned: false }
+}
+/// The onion routing packet with encrypted data for the next hop.
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_set_onion_routing_packet(this_ptr: &mut UpdateAddHTLC, mut val: crate::lightning::ln::msgs::OnionPacket) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.onion_routing_packet = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
+/// routing packet and the recipient-provided encrypted payload within.
+///
+/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_get_blinding_point(this_ptr: &UpdateAddHTLC) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().blinding_point;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(inner_val.unwrap())) } };
+ local_inner_val
+}
+/// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
+/// routing packet and the recipient-provided encrypted payload within.
+///
+/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_set_blinding_point(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::PublicKey) {
+ let mut local_val = if val.is_null() { None } else { Some( { val.into_rust() }) };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.blinding_point = local_val;
+}
+/// Constructs a new UpdateAddHTLC given each field
+///
+/// Note that blinding_point_arg (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[must_use]
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut htlc_id_arg: u64, mut amount_msat_arg: u64, mut payment_hash_arg: crate::c_types::ThirtyTwoBytes, mut cltv_expiry_arg: u32, mut skimmed_fee_msat_arg: crate::c_types::derived::COption_u64Z, mut onion_routing_packet_arg: crate::lightning::ln::msgs::OnionPacket, mut blinding_point_arg: crate::c_types::PublicKey) -> UpdateAddHTLC {
+ let mut local_skimmed_fee_msat_arg = if skimmed_fee_msat_arg.is_some() { Some( { skimmed_fee_msat_arg.take() }) } else { None };
+ let mut local_blinding_point_arg = if blinding_point_arg.is_null() { None } else { Some( { blinding_point_arg.into_rust() }) };
+ UpdateAddHTLC { inner: ObjOps::heap_alloc(nativeUpdateAddHTLC {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ htlc_id: htlc_id_arg,
+ amount_msat: amount_msat_arg,
+ payment_hash: ::lightning::ln::types::PaymentHash(payment_hash_arg.data),
+ cltv_expiry: cltv_expiry_arg,
+ skimmed_fee_msat: local_skimmed_fee_msat_arg,
+ onion_routing_packet: *unsafe { Box::from_raw(onion_routing_packet_arg.take_inner()) },
+ blinding_point: local_blinding_point_arg,
+ }), is_owned: true }
+}
+impl Clone for UpdateAddHTLC {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeUpdateAddHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 UpdateFailMalformedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUpdateFailMalformedHTLC)).clone() })) as *mut c_void
+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 *const nativeUpdateAddHTLC)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the UpdateFailMalformedHTLC
-pub extern "C" fn UpdateFailMalformedHTLC_clone(orig: &UpdateFailMalformedHTLC) -> UpdateFailMalformedHTLC {
+/// Creates a copy of the UpdateAddHTLC
+pub extern "C" fn UpdateAddHTLC_clone(orig: &UpdateAddHTLC) -> UpdateAddHTLC {
orig.clone()
}
-/// Checks if two UpdateFailMalformedHTLCs contain equal inner contents.
+/// Get a string which allows debug introspection of a UpdateAddHTLC object
+pub extern "C" fn UpdateAddHTLC_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UpdateAddHTLC }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UpdateAddHTLC.
+#[no_mangle]
+pub extern "C" fn UpdateAddHTLC_hash(o: &UpdateAddHTLC) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two UpdateAddHTLCs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn UpdateFailMalformedHTLC_eq(a: &UpdateFailMalformedHTLC, b: &UpdateFailMalformedHTLC) -> bool {
+pub extern "C" fn UpdateAddHTLC_eq(a: &UpdateAddHTLC, b: &UpdateAddHTLC) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::CommitmentSigned as nativeCommitmentSignedImport;
-pub(crate) type nativeCommitmentSigned = nativeCommitmentSignedImport;
+use lightning::ln::msgs::OnionMessage as nativeOnionMessageImport;
+pub(crate) type nativeOnionMessage = nativeOnionMessageImport;
-/// A [`commitment_signed`] message to be sent to or received from a peer.
+/// An onion message to be sent to or received from a peer.
///
-/// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
#[must_use]
#[repr(C)]
-pub struct CommitmentSigned {
+pub struct OnionMessage {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeCommitmentSigned,
+ pub inner: *mut nativeOnionMessage,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for CommitmentSigned {
+impl Drop for OnionMessage {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeCommitmentSigned>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeOnionMessage>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the CommitmentSigned, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the OnionMessage, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn CommitmentSigned_free(this_obj: CommitmentSigned) { }
+pub extern "C" fn OnionMessage_free(this_obj: OnionMessage) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn CommitmentSigned_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeCommitmentSigned) };
+pub(crate) extern "C" fn OnionMessage_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeOnionMessage) };
}
#[allow(unused)]
-impl CommitmentSigned {
- pub(crate) fn get_native_ref(&self) -> &'static nativeCommitmentSigned {
+impl OnionMessage {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeOnionMessage {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeCommitmentSigned {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeOnionMessage {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentSigned {
+ pub(crate) fn take_inner(mut self) -> *mut nativeOnionMessage {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
ret
}
}
-/// The channel ID
-#[no_mangle]
-pub extern "C" fn CommitmentSigned_get_channel_id(this_ptr: &CommitmentSigned) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
-}
-/// The channel ID
-#[no_mangle]
-pub extern "C" fn CommitmentSigned_set_channel_id(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// A signature on the commitment transaction
+/// Used in decrypting the onion packet's payload.
#[no_mangle]
-pub extern "C" fn CommitmentSigned_get_signature(this_ptr: &CommitmentSigned) -> crate::c_types::ECDSASignature {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
- crate::c_types::ECDSASignature::from_rust(&inner_val)
+pub extern "C" fn OnionMessage_get_blinding_point(this_ptr: &OnionMessage) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().blinding_point;
+ crate::c_types::PublicKey::from_rust(&inner_val)
}
-/// A signature on the commitment transaction
+/// Used in decrypting the onion packet's payload.
#[no_mangle]
-pub extern "C" fn CommitmentSigned_set_signature(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::ECDSASignature) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
+pub extern "C" fn OnionMessage_set_blinding_point(this_ptr: &mut OnionMessage, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.blinding_point = val.into_rust();
}
-/// Signatures on the HTLC transactions
-///
-/// Returns a copy of the field.
+/// The full onion packet including hop data, pubkey, and hmac
#[no_mangle]
-pub extern "C" fn CommitmentSigned_get_htlc_signatures(this_ptr: &CommitmentSigned) -> crate::c_types::derived::CVec_ECDSASignatureZ {
- let mut inner_val = this_ptr.get_native_mut_ref().htlc_signatures.clone();
- let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { crate::c_types::ECDSASignature::from_rust(&item) }); };
- local_inner_val.into()
+pub extern "C" fn OnionMessage_get_onion_routing_packet(this_ptr: &OnionMessage) -> crate::lightning::onion_message::packet::Packet {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().onion_routing_packet;
+ crate::lightning::onion_message::packet::Packet { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::onion_message::packet::Packet<>) as *mut _) }, is_owned: false }
}
-/// Signatures on the HTLC transactions
+/// The full onion packet including hop data, pubkey, and hmac
#[no_mangle]
-pub extern "C" fn CommitmentSigned_set_htlc_signatures(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::derived::CVec_ECDSASignatureZ) {
- let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_rust() }); };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_signatures = local_val;
+pub extern "C" fn OnionMessage_set_onion_routing_packet(this_ptr: &mut OnionMessage, mut val: crate::lightning::onion_message::packet::Packet) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.onion_routing_packet = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// Constructs a new CommitmentSigned given each field
+/// Constructs a new OnionMessage given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn CommitmentSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::ECDSASignature, mut htlc_signatures_arg: crate::c_types::derived::CVec_ECDSASignatureZ) -> CommitmentSigned {
- let mut local_htlc_signatures_arg = Vec::new(); for mut item in htlc_signatures_arg.into_rust().drain(..) { local_htlc_signatures_arg.push( { item.into_rust() }); };
- CommitmentSigned { inner: ObjOps::heap_alloc(nativeCommitmentSigned {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- signature: signature_arg.into_rust(),
- htlc_signatures: local_htlc_signatures_arg,
+pub extern "C" fn OnionMessage_new(mut blinding_point_arg: crate::c_types::PublicKey, mut onion_routing_packet_arg: crate::lightning::onion_message::packet::Packet) -> OnionMessage {
+ OnionMessage { inner: ObjOps::heap_alloc(nativeOnionMessage {
+ blinding_point: blinding_point_arg.into_rust(),
+ onion_routing_packet: *unsafe { Box::from_raw(onion_routing_packet_arg.take_inner()) },
}), is_owned: true }
}
-impl Clone for CommitmentSigned {
+impl Clone for OnionMessage {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeCommitmentSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeOnionMessage>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 CommitmentSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeCommitmentSigned)).clone() })) as *mut c_void
+pub(crate) extern "C" fn OnionMessage_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeOnionMessage)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the CommitmentSigned
-pub extern "C" fn CommitmentSigned_clone(orig: &CommitmentSigned) -> CommitmentSigned {
+/// Creates a copy of the OnionMessage
+pub extern "C" fn OnionMessage_clone(orig: &OnionMessage) -> OnionMessage {
orig.clone()
}
-/// Checks if two CommitmentSigneds contain equal inner contents.
+/// Get a string which allows debug introspection of a OnionMessage object
+pub extern "C" fn OnionMessage_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::OnionMessage }).into()}
+/// Generates a non-cryptographic 64-bit hash of the OnionMessage.
+#[no_mangle]
+pub extern "C" fn OnionMessage_hash(o: &OnionMessage) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two OnionMessages contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn CommitmentSigned_eq(a: &CommitmentSigned, b: &CommitmentSigned) -> bool {
+pub extern "C" fn OnionMessage_eq(a: &OnionMessage, b: &OnionMessage) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::RevokeAndACK as nativeRevokeAndACKImport;
-pub(crate) type nativeRevokeAndACK = nativeRevokeAndACKImport;
+use lightning::ln::msgs::UpdateFulfillHTLC as nativeUpdateFulfillHTLCImport;
+pub(crate) type nativeUpdateFulfillHTLC = nativeUpdateFulfillHTLCImport;
-/// A [`revoke_and_ack`] message to be sent to or received from a peer.
+/// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
///
-/// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
+/// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
#[must_use]
#[repr(C)]
-pub struct RevokeAndACK {
+pub struct UpdateFulfillHTLC {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeRevokeAndACK,
+ pub inner: *mut nativeUpdateFulfillHTLC,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for RevokeAndACK {
+impl Drop for UpdateFulfillHTLC {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeRevokeAndACK>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeUpdateFulfillHTLC>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the RevokeAndACK, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the UpdateFulfillHTLC, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn RevokeAndACK_free(this_obj: RevokeAndACK) { }
+pub extern "C" fn UpdateFulfillHTLC_free(this_obj: UpdateFulfillHTLC) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn RevokeAndACK_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRevokeAndACK) };
+pub(crate) extern "C" fn UpdateFulfillHTLC_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFulfillHTLC) };
}
#[allow(unused)]
-impl RevokeAndACK {
- pub(crate) fn get_native_ref(&self) -> &'static nativeRevokeAndACK {
+impl UpdateFulfillHTLC {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFulfillHTLC {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRevokeAndACK {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFulfillHTLC {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeRevokeAndACK {
+ pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFulfillHTLC {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn RevokeAndACK_get_channel_id(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
+pub extern "C" fn UpdateFulfillHTLC_get_channel_id(this_ptr: &UpdateFulfillHTLC) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn RevokeAndACK_set_channel_id(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn UpdateFulfillHTLC_set_channel_id(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The secret corresponding to the per-commitment point
+/// The HTLC ID
#[no_mangle]
-pub extern "C" fn RevokeAndACK_get_per_commitment_secret(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().per_commitment_secret;
- inner_val
+pub extern "C" fn UpdateFulfillHTLC_get_htlc_id(this_ptr: &UpdateFulfillHTLC) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
+ *inner_val
}
-/// The secret corresponding to the per-commitment point
+/// The HTLC ID
#[no_mangle]
-pub extern "C" fn RevokeAndACK_set_per_commitment_secret(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.per_commitment_secret = val.data;
+pub extern "C" fn UpdateFulfillHTLC_set_htlc_id(this_ptr: &mut UpdateFulfillHTLC, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
}
-/// The next sender-broadcast commitment transaction's per-commitment point
+/// The pre-image of the payment hash, allowing HTLC redemption
#[no_mangle]
-pub extern "C" fn RevokeAndACK_get_next_per_commitment_point(this_ptr: &RevokeAndACK) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().next_per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
+pub extern "C" fn UpdateFulfillHTLC_get_payment_preimage(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_preimage;
+ &inner_val.0
}
-/// The next sender-broadcast commitment transaction's per-commitment point
+/// The pre-image of the payment hash, allowing HTLC redemption
#[no_mangle]
-pub extern "C" fn RevokeAndACK_set_next_per_commitment_point(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_per_commitment_point = val.into_rust();
+pub extern "C" fn UpdateFulfillHTLC_set_payment_preimage(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_preimage = ::lightning::ln::types::PaymentPreimage(val.data);
}
-/// Constructs a new RevokeAndACK given each field
+/// Constructs a new UpdateFulfillHTLC given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn RevokeAndACK_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey) -> RevokeAndACK {
- RevokeAndACK { inner: ObjOps::heap_alloc(nativeRevokeAndACK {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- per_commitment_secret: per_commitment_secret_arg.data,
- next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
+pub extern "C" fn UpdateFulfillHTLC_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut htlc_id_arg: u64, mut payment_preimage_arg: crate::c_types::ThirtyTwoBytes) -> UpdateFulfillHTLC {
+ UpdateFulfillHTLC { inner: ObjOps::heap_alloc(nativeUpdateFulfillHTLC {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ htlc_id: htlc_id_arg,
+ payment_preimage: ::lightning::ln::types::PaymentPreimage(payment_preimage_arg.data),
}), is_owned: true }
}
-impl Clone for RevokeAndACK {
+impl Clone for UpdateFulfillHTLC {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeRevokeAndACK>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeUpdateFulfillHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 RevokeAndACK_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeRevokeAndACK)).clone() })) as *mut c_void
+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 *const nativeUpdateFulfillHTLC)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the RevokeAndACK
-pub extern "C" fn RevokeAndACK_clone(orig: &RevokeAndACK) -> RevokeAndACK {
+/// Creates a copy of the UpdateFulfillHTLC
+pub extern "C" fn UpdateFulfillHTLC_clone(orig: &UpdateFulfillHTLC) -> UpdateFulfillHTLC {
orig.clone()
}
-/// Checks if two RevokeAndACKs contain equal inner contents.
+/// Get a string which allows debug introspection of a UpdateFulfillHTLC object
+pub extern "C" fn UpdateFulfillHTLC_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UpdateFulfillHTLC }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UpdateFulfillHTLC.
+#[no_mangle]
+pub extern "C" fn UpdateFulfillHTLC_hash(o: &UpdateFulfillHTLC) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two UpdateFulfillHTLCs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn RevokeAndACK_eq(a: &RevokeAndACK, b: &RevokeAndACK) -> bool {
+pub extern "C" fn UpdateFulfillHTLC_eq(a: &UpdateFulfillHTLC, b: &UpdateFulfillHTLC) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::UpdateFee as nativeUpdateFeeImport;
-pub(crate) type nativeUpdateFee = nativeUpdateFeeImport;
+use lightning::ln::msgs::UpdateFailHTLC as nativeUpdateFailHTLCImport;
+pub(crate) type nativeUpdateFailHTLC = nativeUpdateFailHTLCImport;
-/// An [`update_fee`] message to be sent to or received from a peer
+/// An [`update_fail_htlc`] message to be sent to or received from a peer.
///
-/// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
+/// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
#[must_use]
#[repr(C)]
-pub struct UpdateFee {
+pub struct UpdateFailHTLC {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeUpdateFee,
+ pub inner: *mut nativeUpdateFailHTLC,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for UpdateFee {
+impl Drop for UpdateFailHTLC {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeUpdateFee>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeUpdateFailHTLC>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the UpdateFee, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the UpdateFailHTLC, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn UpdateFee_free(this_obj: UpdateFee) { }
+pub extern "C" fn UpdateFailHTLC_free(this_obj: UpdateFailHTLC) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn UpdateFee_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFee) };
+pub(crate) extern "C" fn UpdateFailHTLC_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFailHTLC) };
}
#[allow(unused)]
-impl UpdateFee {
- pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFee {
+impl UpdateFailHTLC {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFailHTLC {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFee {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFailHTLC {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFee {
+ pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailHTLC {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateFee_get_channel_id(this_ptr: &UpdateFee) -> *const [u8; 32] {
+pub extern "C" fn UpdateFailHTLC_get_channel_id(this_ptr: &UpdateFailHTLC) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn UpdateFee_set_channel_id(this_ptr: &mut UpdateFee, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn UpdateFailHTLC_set_channel_id(this_ptr: &mut UpdateFailHTLC, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// Fee rate per 1000-weight of the transaction
+/// The HTLC ID
#[no_mangle]
-pub extern "C" fn UpdateFee_get_feerate_per_kw(this_ptr: &UpdateFee) -> u32 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_per_kw;
+pub extern "C" fn UpdateFailHTLC_get_htlc_id(this_ptr: &UpdateFailHTLC) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
*inner_val
}
-/// Fee rate per 1000-weight of the transaction
-#[no_mangle]
-pub extern "C" fn UpdateFee_set_feerate_per_kw(this_ptr: &mut UpdateFee, mut val: u32) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_per_kw = val;
-}
-/// Constructs a new UpdateFee given each field
-#[must_use]
+/// The HTLC ID
#[no_mangle]
-pub extern "C" fn UpdateFee_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut feerate_per_kw_arg: u32) -> UpdateFee {
- UpdateFee { inner: ObjOps::heap_alloc(nativeUpdateFee {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- feerate_per_kw: feerate_per_kw_arg,
- }), is_owned: true }
+pub extern "C" fn UpdateFailHTLC_set_htlc_id(this_ptr: &mut UpdateFailHTLC, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
}
-impl Clone for UpdateFee {
+impl Clone for UpdateFailHTLC {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeUpdateFee>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeUpdateFailHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 UpdateFee_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUpdateFee)).clone() })) as *mut c_void
+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 *const nativeUpdateFailHTLC)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the UpdateFee
-pub extern "C" fn UpdateFee_clone(orig: &UpdateFee) -> UpdateFee {
+/// Creates a copy of the UpdateFailHTLC
+pub extern "C" fn UpdateFailHTLC_clone(orig: &UpdateFailHTLC) -> UpdateFailHTLC {
orig.clone()
}
-/// Checks if two UpdateFees contain equal inner contents.
+/// Get a string which allows debug introspection of a UpdateFailHTLC object
+pub extern "C" fn UpdateFailHTLC_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UpdateFailHTLC }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UpdateFailHTLC.
+#[no_mangle]
+pub extern "C" fn UpdateFailHTLC_hash(o: &UpdateFailHTLC) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two UpdateFailHTLCs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn UpdateFee_eq(a: &UpdateFee, b: &UpdateFee) -> bool {
+pub extern "C" fn UpdateFailHTLC_eq(a: &UpdateFailHTLC, b: &UpdateFailHTLC) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::ChannelReestablish as nativeChannelReestablishImport;
-pub(crate) type nativeChannelReestablish = nativeChannelReestablishImport;
+use lightning::ln::msgs::UpdateFailMalformedHTLC as nativeUpdateFailMalformedHTLCImport;
+pub(crate) type nativeUpdateFailMalformedHTLC = nativeUpdateFailMalformedHTLCImport;
-/// A [`channel_reestablish`] message to be sent to or received from a peer.
+/// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
///
-/// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
+/// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
#[must_use]
#[repr(C)]
-pub struct ChannelReestablish {
+pub struct UpdateFailMalformedHTLC {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeChannelReestablish,
+ pub inner: *mut nativeUpdateFailMalformedHTLC,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for ChannelReestablish {
+impl Drop for UpdateFailMalformedHTLC {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeChannelReestablish>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the ChannelReestablish, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the UpdateFailMalformedHTLC, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn ChannelReestablish_free(this_obj: ChannelReestablish) { }
+pub extern "C" fn UpdateFailMalformedHTLC_free(this_obj: UpdateFailMalformedHTLC) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn ChannelReestablish_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeChannelReestablish) };
+pub(crate) extern "C" fn UpdateFailMalformedHTLC_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFailMalformedHTLC) };
}
#[allow(unused)]
-impl ChannelReestablish {
- pub(crate) fn get_native_ref(&self) -> &'static nativeChannelReestablish {
+impl UpdateFailMalformedHTLC {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFailMalformedHTLC {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeChannelReestablish {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFailMalformedHTLC {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeChannelReestablish {
+ pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailMalformedHTLC {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn ChannelReestablish_get_channel_id(this_ptr: &ChannelReestablish) -> *const [u8; 32] {
+pub extern "C" fn UpdateFailMalformedHTLC_get_channel_id(this_ptr: &UpdateFailMalformedHTLC) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn ChannelReestablish_set_channel_id(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
+pub extern "C" fn UpdateFailMalformedHTLC_set_channel_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// The next commitment number for the sender
+/// The HTLC ID
#[no_mangle]
-pub extern "C" fn ChannelReestablish_get_next_local_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().next_local_commitment_number;
+pub extern "C" fn UpdateFailMalformedHTLC_get_htlc_id(this_ptr: &UpdateFailMalformedHTLC) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
*inner_val
}
-/// The next commitment number for the sender
+/// The HTLC ID
#[no_mangle]
-pub extern "C" fn ChannelReestablish_set_next_local_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_local_commitment_number = val;
+pub extern "C" fn UpdateFailMalformedHTLC_set_htlc_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
}
-/// The next commitment number for the recipient
+/// The failure code
#[no_mangle]
-pub extern "C" fn ChannelReestablish_get_next_remote_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().next_remote_commitment_number;
+pub extern "C" fn UpdateFailMalformedHTLC_get_failure_code(this_ptr: &UpdateFailMalformedHTLC) -> u16 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().failure_code;
*inner_val
}
-/// The next commitment number for the recipient
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_set_next_remote_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_remote_commitment_number = val;
-}
-/// Proof that the sender knows the per-commitment secret of a specific commitment transaction
-/// belonging to the recipient
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: &ChannelReestablish) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().your_last_per_commitment_secret;
- inner_val
-}
-/// Proof that the sender knows the per-commitment secret of a specific commitment transaction
-/// belonging to the recipient
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.your_last_per_commitment_secret = val.data;
-}
-/// The sender's per-commitment point for their current commitment transaction
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_get_my_current_per_commitment_point(this_ptr: &ChannelReestablish) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().my_current_per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The sender's per-commitment point for their current commitment transaction
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_set_my_current_per_commitment_point(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.my_current_per_commitment_point = val.into_rust();
-}
-/// The next funding transaction ID
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_get_next_funding_txid(this_ptr: &ChannelReestablish) -> crate::c_types::derived::COption_ThirtyTwoBytesZ {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().next_funding_txid;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { crate::c_types::ThirtyTwoBytes { data: (*inner_val.as_ref().unwrap()).clone().into_inner() } }) };
- local_inner_val
-}
-/// The next funding transaction ID
-#[no_mangle]
-pub extern "C" fn ChannelReestablish_set_next_funding_txid(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::derived::COption_ThirtyTwoBytesZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::hash_types::Txid::from_slice(&{ val_opt.take() }.data[..]).unwrap() }})} };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_funding_txid = local_val;
-}
-/// Constructs a new ChannelReestablish given each field
-#[must_use]
+/// The failure code
#[no_mangle]
-pub extern "C" fn ChannelReestablish_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut next_local_commitment_number_arg: u64, mut next_remote_commitment_number_arg: u64, mut your_last_per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut my_current_per_commitment_point_arg: crate::c_types::PublicKey, mut next_funding_txid_arg: crate::c_types::derived::COption_ThirtyTwoBytesZ) -> ChannelReestablish {
- let mut local_next_funding_txid_arg = { /*next_funding_txid_arg*/ let next_funding_txid_arg_opt = next_funding_txid_arg; if next_funding_txid_arg_opt.is_none() { None } else { Some({ { ::bitcoin::hash_types::Txid::from_slice(&{ next_funding_txid_arg_opt.take() }.data[..]).unwrap() }})} };
- ChannelReestablish { inner: ObjOps::heap_alloc(nativeChannelReestablish {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- next_local_commitment_number: next_local_commitment_number_arg,
- next_remote_commitment_number: next_remote_commitment_number_arg,
- your_last_per_commitment_secret: your_last_per_commitment_secret_arg.data,
- my_current_per_commitment_point: my_current_per_commitment_point_arg.into_rust(),
- next_funding_txid: local_next_funding_txid_arg,
- }), is_owned: true }
+pub extern "C" fn UpdateFailMalformedHTLC_set_failure_code(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u16) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.failure_code = val;
}
-impl Clone for ChannelReestablish {
+impl Clone for UpdateFailMalformedHTLC {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeChannelReestablish>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 ChannelReestablish_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeChannelReestablish)).clone() })) as *mut c_void
+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 *const nativeUpdateFailMalformedHTLC)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the ChannelReestablish
-pub extern "C" fn ChannelReestablish_clone(orig: &ChannelReestablish) -> ChannelReestablish {
+/// Creates a copy of the UpdateFailMalformedHTLC
+pub extern "C" fn UpdateFailMalformedHTLC_clone(orig: &UpdateFailMalformedHTLC) -> UpdateFailMalformedHTLC {
orig.clone()
}
-/// Checks if two ChannelReestablishs contain equal inner contents.
+/// Get a string which allows debug introspection of a UpdateFailMalformedHTLC object
+pub extern "C" fn UpdateFailMalformedHTLC_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UpdateFailMalformedHTLC }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UpdateFailMalformedHTLC.
+#[no_mangle]
+pub extern "C" fn UpdateFailMalformedHTLC_hash(o: &UpdateFailMalformedHTLC) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two UpdateFailMalformedHTLCs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn ChannelReestablish_eq(a: &ChannelReestablish, b: &ChannelReestablish) -> bool {
+pub extern "C" fn UpdateFailMalformedHTLC_eq(a: &UpdateFailMalformedHTLC, b: &UpdateFailMalformedHTLC) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-use lightning::ln::msgs::AnnouncementSignatures as nativeAnnouncementSignaturesImport;
-pub(crate) type nativeAnnouncementSignatures = nativeAnnouncementSignaturesImport;
+use lightning::ln::msgs::CommitmentSigned as nativeCommitmentSignedImport;
+pub(crate) type nativeCommitmentSigned = nativeCommitmentSignedImport;
-/// An [`announcement_signatures`] message to be sent to or received from a peer.
+/// A [`commitment_signed`] message to be sent to or received from a peer.
///
-/// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
+/// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
#[must_use]
#[repr(C)]
-pub struct AnnouncementSignatures {
+pub struct CommitmentSigned {
/// A pointer to the opaque Rust object.
/// Nearly everywhere, inner must be non-null, however in places where
/// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeAnnouncementSignatures,
+ pub inner: *mut nativeCommitmentSigned,
/// Indicates that this is the only struct which contains the same pointer.
/// Rust functions which take ownership of an object provided via an argument require
pub is_owned: bool,
}
-impl Drop for AnnouncementSignatures {
+impl Drop for CommitmentSigned {
fn drop(&mut self) {
- if self.is_owned && !<*mut nativeAnnouncementSignatures>::is_null(self.inner) {
+ if self.is_owned && !<*mut nativeCommitmentSigned>::is_null(self.inner) {
let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// Frees any resources used by the AnnouncementSignatures, if is_owned is set and inner is non-NULL.
+/// Frees any resources used by the CommitmentSigned, if is_owned is set and inner is non-NULL.
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_free(this_obj: AnnouncementSignatures) { }
+pub extern "C" fn CommitmentSigned_free(this_obj: CommitmentSigned) { }
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn AnnouncementSignatures_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeAnnouncementSignatures) };
+pub(crate) extern "C" fn CommitmentSigned_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeCommitmentSigned) };
}
#[allow(unused)]
-impl AnnouncementSignatures {
- pub(crate) fn get_native_ref(&self) -> &'static nativeAnnouncementSignatures {
+impl CommitmentSigned {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeCommitmentSigned {
unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeAnnouncementSignatures {
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeCommitmentSigned {
unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeAnnouncementSignatures {
+ pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentSigned {
assert!(self.is_owned);
let ret = ObjOps::untweak_ptr(self.inner);
self.inner = core::ptr::null_mut();
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_get_channel_id(this_ptr: &AnnouncementSignatures) -> *const [u8; 32] {
+pub extern "C" fn CommitmentSigned_get_channel_id(this_ptr: &CommitmentSigned) -> crate::lightning::ln::types::ChannelId {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
- &inner_val.0
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
}
/// The channel ID
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_set_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
-}
-/// The short channel ID
-#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_get_short_channel_id(this_ptr: &AnnouncementSignatures) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
- *inner_val
-}
-/// The short channel ID
-#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_set_short_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
+pub extern "C" fn CommitmentSigned_set_channel_id(this_ptr: &mut CommitmentSigned, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
}
-/// A signature by the node key
+/// A signature on the commitment transaction
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_get_node_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::ECDSASignature {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().node_signature;
+pub extern "C" fn CommitmentSigned_get_signature(this_ptr: &CommitmentSigned) -> crate::c_types::ECDSASignature {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
crate::c_types::ECDSASignature::from_rust(&inner_val)
}
-/// A signature by the node key
+/// A signature on the commitment transaction
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_set_node_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ECDSASignature) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_signature = val.into_rust();
+pub extern "C" fn CommitmentSigned_set_signature(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::ECDSASignature) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
}
-/// A signature by the funding key
+/// Signatures on the HTLC transactions
+///
+/// Returns a copy of the field.
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_get_bitcoin_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::ECDSASignature {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_signature;
- crate::c_types::ECDSASignature::from_rust(&inner_val)
+pub extern "C" fn CommitmentSigned_get_htlc_signatures(this_ptr: &CommitmentSigned) -> crate::c_types::derived::CVec_ECDSASignatureZ {
+ let mut inner_val = this_ptr.get_native_mut_ref().htlc_signatures.clone();
+ let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { crate::c_types::ECDSASignature::from_rust(&item) }); };
+ local_inner_val.into()
}
-/// A signature by the funding key
+/// Signatures on the HTLC transactions
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_set_bitcoin_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ECDSASignature) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_signature = val.into_rust();
+pub extern "C" fn CommitmentSigned_set_htlc_signatures(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::derived::CVec_ECDSASignatureZ) {
+ let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_rust() }); };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_signatures = local_val;
}
-/// Constructs a new AnnouncementSignatures given each field
+/// Constructs a new CommitmentSigned given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut short_channel_id_arg: u64, mut node_signature_arg: crate::c_types::ECDSASignature, mut bitcoin_signature_arg: crate::c_types::ECDSASignature) -> AnnouncementSignatures {
- AnnouncementSignatures { inner: ObjOps::heap_alloc(nativeAnnouncementSignatures {
- channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
- short_channel_id: short_channel_id_arg,
- node_signature: node_signature_arg.into_rust(),
- bitcoin_signature: bitcoin_signature_arg.into_rust(),
+pub extern "C" fn CommitmentSigned_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut signature_arg: crate::c_types::ECDSASignature, mut htlc_signatures_arg: crate::c_types::derived::CVec_ECDSASignatureZ) -> CommitmentSigned {
+ let mut local_htlc_signatures_arg = Vec::new(); for mut item in htlc_signatures_arg.into_rust().drain(..) { local_htlc_signatures_arg.push( { item.into_rust() }); };
+ CommitmentSigned { inner: ObjOps::heap_alloc(nativeCommitmentSigned {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ signature: signature_arg.into_rust(),
+ htlc_signatures: local_htlc_signatures_arg,
}), is_owned: true }
}
-impl Clone for AnnouncementSignatures {
+impl Clone for CommitmentSigned {
fn clone(&self) -> Self {
Self {
- inner: if <*mut nativeAnnouncementSignatures>::is_null(self.inner) { core::ptr::null_mut() } else {
+ inner: if <*mut nativeCommitmentSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 AnnouncementSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeAnnouncementSignatures)).clone() })) as *mut c_void
+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 *const nativeCommitmentSigned)).clone() })) as *mut c_void
}
#[no_mangle]
-/// Creates a copy of the AnnouncementSignatures
-pub extern "C" fn AnnouncementSignatures_clone(orig: &AnnouncementSignatures) -> AnnouncementSignatures {
+/// Creates a copy of the CommitmentSigned
+pub extern "C" fn CommitmentSigned_clone(orig: &CommitmentSigned) -> CommitmentSigned {
orig.clone()
}
-/// Checks if two AnnouncementSignaturess contain equal inner contents.
+/// Get a string which allows debug introspection of a CommitmentSigned object
+pub extern "C" fn CommitmentSigned_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::CommitmentSigned }).into()}
+/// Generates a non-cryptographic 64-bit hash of the CommitmentSigned.
+#[no_mangle]
+pub extern "C" fn CommitmentSigned_hash(o: &CommitmentSigned) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two CommitmentSigneds contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
-pub extern "C" fn AnnouncementSignatures_eq(a: &AnnouncementSignatures, b: &AnnouncementSignatures) -> bool {
+pub extern "C" fn CommitmentSigned_eq(a: &CommitmentSigned, b: &CommitmentSigned) -> bool {
if a.inner == b.inner { return true; }
if a.inner.is_null() || b.inner.is_null() { return false; }
if a.get_native_ref() == b.get_native_ref() { true } else { false }
}
-/// An address which can be used to connect to a remote peer.
-#[derive(Clone)]
+
+use lightning::ln::msgs::RevokeAndACK as nativeRevokeAndACKImport;
+pub(crate) type nativeRevokeAndACK = nativeRevokeAndACKImport;
+
+/// A [`revoke_and_ack`] message to be sent to or received from a peer.
+///
+/// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
#[must_use]
#[repr(C)]
-pub enum SocketAddress {
- /// An IPv4 address and port on which the peer is listening.
- TcpIpV4 {
- /// The 4-byte IPv4 address
- addr: crate::c_types::FourBytes,
- /// The port on which the node is listening
- port: u16,
- },
- /// An IPv6 address and port on which the peer is listening.
- TcpIpV6 {
- /// The 16-byte IPv6 address
- addr: crate::c_types::SixteenBytes,
- /// The port on which the node is listening
- port: u16,
- },
- /// An old-style Tor onion address/port on which the peer is listening.
- ///
- /// This field is deprecated and the Tor network generally no longer supports V2 Onion
- /// addresses. Thus, the details are not parsed here.
- OnionV2(
- crate::c_types::TwelveBytes),
- /// A new-style Tor onion address/port on which the peer is listening.
- ///
- /// To create the human-readable \"hostname\", concatenate the ED25519 pubkey, checksum, and version,
- /// wrap as base32 and append \".onion\".
- OnionV3 {
- /// The ed25519 long-term public key of the peer
- ed25519_pubkey: crate::c_types::ThirtyTwoBytes,
- /// The checksum of the pubkey and version, as included in the onion address
- checksum: u16,
- /// The version byte, as defined by the Tor Onion v3 spec.
- version: u8,
- /// The port on which the node is listening
- port: u16,
- },
- /// A hostname/port on which the peer is listening.
- Hostname {
- /// The hostname on which the node is listening.
- hostname: crate::lightning::util::ser::Hostname,
- /// The port on which the node is listening.
- port: u16,
- },
-}
+pub struct RevokeAndACK {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeRevokeAndACK,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for RevokeAndACK {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeRevokeAndACK>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the RevokeAndACK, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_free(this_obj: RevokeAndACK) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn RevokeAndACK_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRevokeAndACK) };
+}
+#[allow(unused)]
+impl RevokeAndACK {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeRevokeAndACK {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRevokeAndACK {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeRevokeAndACK {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_get_channel_id(this_ptr: &RevokeAndACK) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_set_channel_id(this_ptr: &mut RevokeAndACK, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The secret corresponding to the per-commitment point
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_get_per_commitment_secret(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().per_commitment_secret;
+ inner_val
+}
+/// The secret corresponding to the per-commitment point
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_set_per_commitment_secret(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.per_commitment_secret = val.data;
+}
+/// The next sender-broadcast commitment transaction's per-commitment point
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_get_next_per_commitment_point(this_ptr: &RevokeAndACK) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().next_per_commitment_point;
+ crate::c_types::PublicKey::from_rust(&inner_val)
+}
+/// The next sender-broadcast commitment transaction's per-commitment point
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_set_next_per_commitment_point(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_per_commitment_point = val.into_rust();
+}
+/// Constructs a new RevokeAndACK given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey) -> RevokeAndACK {
+ RevokeAndACK { inner: ObjOps::heap_alloc(nativeRevokeAndACK {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ per_commitment_secret: per_commitment_secret_arg.data,
+ next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
+ }), is_owned: true }
+}
+impl Clone for RevokeAndACK {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeRevokeAndACK>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 RevokeAndACK_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeRevokeAndACK)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the RevokeAndACK
+pub extern "C" fn RevokeAndACK_clone(orig: &RevokeAndACK) -> RevokeAndACK {
+ orig.clone()
+}
+/// Get a string which allows debug introspection of a RevokeAndACK object
+pub extern "C" fn RevokeAndACK_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::RevokeAndACK }).into()}
+/// Generates a non-cryptographic 64-bit hash of the RevokeAndACK.
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_hash(o: &RevokeAndACK) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two RevokeAndACKs contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn RevokeAndACK_eq(a: &RevokeAndACK, b: &RevokeAndACK) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+
+use lightning::ln::msgs::UpdateFee as nativeUpdateFeeImport;
+pub(crate) type nativeUpdateFee = nativeUpdateFeeImport;
+
+/// An [`update_fee`] message to be sent to or received from a peer
+///
+/// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
+#[must_use]
+#[repr(C)]
+pub struct UpdateFee {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeUpdateFee,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for UpdateFee {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeUpdateFee>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the UpdateFee, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn UpdateFee_free(this_obj: UpdateFee) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn UpdateFee_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeUpdateFee) };
+}
+#[allow(unused)]
+impl UpdateFee {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFee {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFee {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFee {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn UpdateFee_get_channel_id(this_ptr: &UpdateFee) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn UpdateFee_set_channel_id(this_ptr: &mut UpdateFee, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// Fee rate per 1000-weight of the transaction
+#[no_mangle]
+pub extern "C" fn UpdateFee_get_feerate_per_kw(this_ptr: &UpdateFee) -> u32 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_per_kw;
+ *inner_val
+}
+/// Fee rate per 1000-weight of the transaction
+#[no_mangle]
+pub extern "C" fn UpdateFee_set_feerate_per_kw(this_ptr: &mut UpdateFee, mut val: u32) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_per_kw = val;
+}
+/// Constructs a new UpdateFee given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn UpdateFee_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut feerate_per_kw_arg: u32) -> UpdateFee {
+ UpdateFee { inner: ObjOps::heap_alloc(nativeUpdateFee {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ feerate_per_kw: feerate_per_kw_arg,
+ }), is_owned: true }
+}
+impl Clone for UpdateFee {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeUpdateFee>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 UpdateFee_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUpdateFee)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the UpdateFee
+pub extern "C" fn UpdateFee_clone(orig: &UpdateFee) -> UpdateFee {
+ orig.clone()
+}
+/// Get a string which allows debug introspection of a UpdateFee object
+pub extern "C" fn UpdateFee_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UpdateFee }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UpdateFee.
+#[no_mangle]
+pub extern "C" fn UpdateFee_hash(o: &UpdateFee) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two UpdateFees contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn UpdateFee_eq(a: &UpdateFee, b: &UpdateFee) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+
+use lightning::ln::msgs::ChannelReestablish as nativeChannelReestablishImport;
+pub(crate) type nativeChannelReestablish = nativeChannelReestablishImport;
+
+/// A [`channel_reestablish`] message to be sent to or received from a peer.
+///
+/// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
+#[must_use]
+#[repr(C)]
+pub struct ChannelReestablish {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeChannelReestablish,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for ChannelReestablish {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeChannelReestablish>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the ChannelReestablish, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_free(this_obj: ChannelReestablish) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn ChannelReestablish_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeChannelReestablish) };
+}
+#[allow(unused)]
+impl ChannelReestablish {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeChannelReestablish {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeChannelReestablish {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeChannelReestablish {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_get_channel_id(this_ptr: &ChannelReestablish) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_set_channel_id(this_ptr: &mut ChannelReestablish, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The next commitment number for the sender
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_get_next_local_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().next_local_commitment_number;
+ *inner_val
+}
+/// The next commitment number for the sender
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_set_next_local_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_local_commitment_number = val;
+}
+/// The next commitment number for the recipient
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_get_next_remote_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().next_remote_commitment_number;
+ *inner_val
+}
+/// The next commitment number for the recipient
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_set_next_remote_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_remote_commitment_number = val;
+}
+/// Proof that the sender knows the per-commitment secret of a specific commitment transaction
+/// belonging to the recipient
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: &ChannelReestablish) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().your_last_per_commitment_secret;
+ inner_val
+}
+/// Proof that the sender knows the per-commitment secret of a specific commitment transaction
+/// belonging to the recipient
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.your_last_per_commitment_secret = val.data;
+}
+/// The sender's per-commitment point for their current commitment transaction
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_get_my_current_per_commitment_point(this_ptr: &ChannelReestablish) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().my_current_per_commitment_point;
+ crate::c_types::PublicKey::from_rust(&inner_val)
+}
+/// The sender's per-commitment point for their current commitment transaction
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_set_my_current_per_commitment_point(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.my_current_per_commitment_point = val.into_rust();
+}
+/// The next funding transaction ID
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_get_next_funding_txid(this_ptr: &ChannelReestablish) -> crate::c_types::derived::COption_ThirtyTwoBytesZ {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().next_funding_txid;
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { crate::c_types::ThirtyTwoBytes { data: *(*inner_val.as_ref().unwrap()).clone().as_ref() } }) };
+ local_inner_val
+}
+/// The next funding transaction ID
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_set_next_funding_txid(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::derived::COption_ThirtyTwoBytesZ) {
+ let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::bitcoin::hash_types::Txid::from_slice(&{ val_opt.take() }.data[..]).unwrap() }})} };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_funding_txid = local_val;
+}
+/// Constructs a new ChannelReestablish given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut next_local_commitment_number_arg: u64, mut next_remote_commitment_number_arg: u64, mut your_last_per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut my_current_per_commitment_point_arg: crate::c_types::PublicKey, mut next_funding_txid_arg: crate::c_types::derived::COption_ThirtyTwoBytesZ) -> ChannelReestablish {
+ let mut local_next_funding_txid_arg = { /*next_funding_txid_arg*/ let next_funding_txid_arg_opt = next_funding_txid_arg; if next_funding_txid_arg_opt.is_none() { None } else { Some({ { ::bitcoin::hash_types::Txid::from_slice(&{ next_funding_txid_arg_opt.take() }.data[..]).unwrap() }})} };
+ ChannelReestablish { inner: ObjOps::heap_alloc(nativeChannelReestablish {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ next_local_commitment_number: next_local_commitment_number_arg,
+ next_remote_commitment_number: next_remote_commitment_number_arg,
+ your_last_per_commitment_secret: your_last_per_commitment_secret_arg.data,
+ my_current_per_commitment_point: my_current_per_commitment_point_arg.into_rust(),
+ next_funding_txid: local_next_funding_txid_arg,
+ }), is_owned: true }
+}
+impl Clone for ChannelReestablish {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeChannelReestablish>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 ChannelReestablish_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeChannelReestablish)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the ChannelReestablish
+pub extern "C" fn ChannelReestablish_clone(orig: &ChannelReestablish) -> ChannelReestablish {
+ orig.clone()
+}
+/// Get a string which allows debug introspection of a ChannelReestablish object
+pub extern "C" fn ChannelReestablish_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ChannelReestablish }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ChannelReestablish.
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_hash(o: &ChannelReestablish) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two ChannelReestablishs contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn ChannelReestablish_eq(a: &ChannelReestablish, b: &ChannelReestablish) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+
+use lightning::ln::msgs::AnnouncementSignatures as nativeAnnouncementSignaturesImport;
+pub(crate) type nativeAnnouncementSignatures = nativeAnnouncementSignaturesImport;
+
+/// An [`announcement_signatures`] message to be sent to or received from a peer.
+///
+/// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
+#[must_use]
+#[repr(C)]
+pub struct AnnouncementSignatures {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeAnnouncementSignatures,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for AnnouncementSignatures {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeAnnouncementSignatures>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the AnnouncementSignatures, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_free(this_obj: AnnouncementSignatures) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn AnnouncementSignatures_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeAnnouncementSignatures) };
+}
+#[allow(unused)]
+impl AnnouncementSignatures {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeAnnouncementSignatures {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeAnnouncementSignatures {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeAnnouncementSignatures {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_get_channel_id(this_ptr: &AnnouncementSignatures) -> crate::lightning::ln::types::ChannelId {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
+ crate::lightning::ln::types::ChannelId { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::types::ChannelId<>) as *mut _) }, is_owned: false }
+}
+/// The channel ID
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_set_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: crate::lightning::ln::types::ChannelId) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// The short channel ID
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_get_short_channel_id(this_ptr: &AnnouncementSignatures) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
+ *inner_val
+}
+/// The short channel ID
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_set_short_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
+}
+/// A signature by the node key
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_get_node_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::ECDSASignature {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().node_signature;
+ crate::c_types::ECDSASignature::from_rust(&inner_val)
+}
+/// A signature by the node key
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_set_node_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ECDSASignature) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_signature = val.into_rust();
+}
+/// A signature by the funding key
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_get_bitcoin_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::ECDSASignature {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_signature;
+ crate::c_types::ECDSASignature::from_rust(&inner_val)
+}
+/// A signature by the funding key
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_set_bitcoin_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ECDSASignature) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_signature = val.into_rust();
+}
+/// Constructs a new AnnouncementSignatures given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_new(mut channel_id_arg: crate::lightning::ln::types::ChannelId, mut short_channel_id_arg: u64, mut node_signature_arg: crate::c_types::ECDSASignature, mut bitcoin_signature_arg: crate::c_types::ECDSASignature) -> AnnouncementSignatures {
+ AnnouncementSignatures { inner: ObjOps::heap_alloc(nativeAnnouncementSignatures {
+ channel_id: *unsafe { Box::from_raw(channel_id_arg.take_inner()) },
+ short_channel_id: short_channel_id_arg,
+ node_signature: node_signature_arg.into_rust(),
+ bitcoin_signature: bitcoin_signature_arg.into_rust(),
+ }), is_owned: true }
+}
+impl Clone for AnnouncementSignatures {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeAnnouncementSignatures>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 AnnouncementSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeAnnouncementSignatures)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the AnnouncementSignatures
+pub extern "C" fn AnnouncementSignatures_clone(orig: &AnnouncementSignatures) -> AnnouncementSignatures {
+ orig.clone()
+}
+/// Get a string which allows debug introspection of a AnnouncementSignatures object
+pub extern "C" fn AnnouncementSignatures_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::AnnouncementSignatures }).into()}
+/// Generates a non-cryptographic 64-bit hash of the AnnouncementSignatures.
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_hash(o: &AnnouncementSignatures) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two AnnouncementSignaturess contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn AnnouncementSignatures_eq(a: &AnnouncementSignatures, b: &AnnouncementSignatures) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+/// An address which can be used to connect to a remote peer.
+#[derive(Clone)]
+#[must_use]
+#[repr(C)]
+pub enum SocketAddress {
+ /// An IPv4 address and port on which the peer is listening.
+ TcpIpV4 {
+ /// The 4-byte IPv4 address
+ addr: crate::c_types::FourBytes,
+ /// The port on which the node is listening
+ port: u16,
+ },
+ /// An IPv6 address and port on which the peer is listening.
+ TcpIpV6 {
+ /// The 16-byte IPv6 address
+ addr: crate::c_types::SixteenBytes,
+ /// The port on which the node is listening
+ port: u16,
+ },
+ /// An old-style Tor onion address/port on which the peer is listening.
+ ///
+ /// This field is deprecated and the Tor network generally no longer supports V2 Onion
+ /// addresses. Thus, the details are not parsed here.
+ OnionV2(
+ crate::c_types::TwelveBytes),
+ /// A new-style Tor onion address/port on which the peer is listening.
+ ///
+ /// To create the human-readable \"hostname\", concatenate the ED25519 pubkey, checksum, and version,
+ /// wrap as base32 and append \".onion\".
+ OnionV3 {
+ /// The ed25519 long-term public key of the peer
+ ed25519_pubkey: crate::c_types::ThirtyTwoBytes,
+ /// The checksum of the pubkey and version, as included in the onion address
+ checksum: u16,
+ /// The version byte, as defined by the Tor Onion v3 spec.
+ version: u8,
+ /// The port on which the node is listening
+ port: u16,
+ },
+ /// A hostname/port on which the peer is listening.
+ Hostname {
+ /// The hostname on which the node is listening.
+ hostname: crate::lightning::util::ser::Hostname,
+ /// The port on which the node is listening.
+ port: u16,
+ },
+}
use lightning::ln::msgs::SocketAddress as SocketAddressImport;
pub(crate) type nativeSocketAddress = SocketAddressImport;
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeSocketAddress) -> Self {
+ pub(crate) fn from_native(native: &SocketAddressImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeSocketAddress) };
match native {
nativeSocketAddress::TcpIpV4 {ref addr, ref port, } => {
let mut addr_nonref = Clone::clone(addr);
port,
}
}
+/// Get a string which allows debug introspection of a SocketAddress object
+pub extern "C" fn SocketAddress_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::SocketAddress }).into()}
+/// Generates a non-cryptographic 64-bit hash of the SocketAddress.
+#[no_mangle]
+pub extern "C" fn SocketAddress_hash(o: &SocketAddress) -> u64 {
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(&o.to_native(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two SocketAddresss contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeSocketAddressParseError) -> Self {
+ pub(crate) fn from_native(native: &SocketAddressParseErrorImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeSocketAddressParseError) };
match native {
nativeSocketAddressParseError::SocketAddrParse => SocketAddressParseError::SocketAddrParse,
nativeSocketAddressParseError::InvalidInput => SocketAddressParseError::InvalidInput,
/// Utility method to constructs a new InvalidOnionV3-variant SocketAddressParseError
pub extern "C" fn SocketAddressParseError_invalid_onion_v3() -> SocketAddressParseError {
SocketAddressParseError::InvalidOnionV3}
+/// Get a string which allows debug introspection of a SocketAddressParseError object
+pub extern "C" fn SocketAddressParseError_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::SocketAddressParseError }).into()}
+/// Generates a non-cryptographic 64-bit hash of the SocketAddressParseError.
+#[no_mangle]
+pub extern "C" fn SocketAddressParseError_hash(o: &SocketAddressParseError) -> u64 {
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(&o.to_native(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two SocketAddressParseErrors contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn SocketAddressParseError_eq(a: &SocketAddressParseError, b: &SocketAddressParseError) -> bool {
if &a.to_native() == &b.to_native() { true } else { false }
}
+#[no_mangle]
+/// Get the string representation of a SocketAddressParseError object
+pub extern "C" fn SocketAddressParseError_to_str(o: &crate::lightning::ln::msgs::SocketAddressParseError) -> Str {
+ alloc::format!("{}", &o.to_native()).into()
+}
/// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
///
/// The host part must end with \".onion\".
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeUnsignedGossipMessage) -> Self {
+ pub(crate) fn from_native(native: &UnsignedGossipMessageImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeUnsignedGossipMessage) };
match native {
nativeUnsignedGossipMessage::ChannelAnnouncement (ref a, ) => {
let mut a_nonref = Clone::clone(a);
let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_native() }); };
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.addresses = local_val;
}
+/// Excess address data which was signed as a part of the message which we do not (yet) understand how
+/// to decode.
+///
+/// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
+///
+/// Returns a copy of the field.
+#[no_mangle]
+pub extern "C" fn UnsignedNodeAnnouncement_get_excess_address_data(this_ptr: &UnsignedNodeAnnouncement) -> crate::c_types::derived::CVec_u8Z {
+ let mut inner_val = this_ptr.get_native_mut_ref().excess_address_data.clone();
+ let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { item }); };
+ local_inner_val.into()
+}
+/// Excess address data which was signed as a part of the message which we do not (yet) understand how
+/// to decode.
+///
+/// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
+#[no_mangle]
+pub extern "C" fn UnsignedNodeAnnouncement_set_excess_address_data(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::derived::CVec_u8Z) {
+ let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.excess_address_data = local_val;
+}
+/// Excess data which was signed as a part of the message which we do not (yet) understand how
+/// to decode.
+///
+/// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
+///
+/// Returns a copy of the field.
+#[no_mangle]
+pub extern "C" fn UnsignedNodeAnnouncement_get_excess_data(this_ptr: &UnsignedNodeAnnouncement) -> crate::c_types::derived::CVec_u8Z {
+ let mut inner_val = this_ptr.get_native_mut_ref().excess_data.clone();
+ let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { item }); };
+ local_inner_val.into()
+}
+/// Excess data which was signed as a part of the message which we do not (yet) understand how
+/// to decode.
+///
+/// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
+#[no_mangle]
+pub extern "C" fn UnsignedNodeAnnouncement_set_excess_data(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::derived::CVec_u8Z) {
+ let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.excess_data = local_val;
+}
+/// Constructs a new UnsignedNodeAnnouncement given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn UnsignedNodeAnnouncement_new(mut features_arg: crate::lightning::ln::features::NodeFeatures, mut timestamp_arg: u32, mut node_id_arg: crate::lightning::routing::gossip::NodeId, mut rgb_arg: crate::c_types::ThreeBytes, mut alias_arg: crate::lightning::routing::gossip::NodeAlias, mut addresses_arg: crate::c_types::derived::CVec_SocketAddressZ, mut excess_address_data_arg: crate::c_types::derived::CVec_u8Z, mut excess_data_arg: crate::c_types::derived::CVec_u8Z) -> UnsignedNodeAnnouncement {
+ let mut local_addresses_arg = Vec::new(); for mut item in addresses_arg.into_rust().drain(..) { local_addresses_arg.push( { item.into_native() }); };
+ let mut local_excess_address_data_arg = Vec::new(); for mut item in excess_address_data_arg.into_rust().drain(..) { local_excess_address_data_arg.push( { item }); };
+ let mut local_excess_data_arg = Vec::new(); for mut item in excess_data_arg.into_rust().drain(..) { local_excess_data_arg.push( { item }); };
+ UnsignedNodeAnnouncement { inner: ObjOps::heap_alloc(nativeUnsignedNodeAnnouncement {
+ features: *unsafe { Box::from_raw(features_arg.take_inner()) },
+ timestamp: timestamp_arg,
+ node_id: *unsafe { Box::from_raw(node_id_arg.take_inner()) },
+ rgb: rgb_arg.data,
+ alias: *unsafe { Box::from_raw(alias_arg.take_inner()) },
+ addresses: local_addresses_arg,
+ excess_address_data: local_excess_address_data_arg,
+ excess_data: local_excess_data_arg,
+ }), is_owned: true }
+}
impl Clone for UnsignedNodeAnnouncement {
fn clone(&self) -> Self {
Self {
pub extern "C" fn UnsignedNodeAnnouncement_clone(orig: &UnsignedNodeAnnouncement) -> UnsignedNodeAnnouncement {
orig.clone()
}
+/// Get a string which allows debug introspection of a UnsignedNodeAnnouncement object
+pub extern "C" fn UnsignedNodeAnnouncement_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UnsignedNodeAnnouncement }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UnsignedNodeAnnouncement.
+#[no_mangle]
+pub extern "C" fn UnsignedNodeAnnouncement_hash(o: &UnsignedNodeAnnouncement) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two UnsignedNodeAnnouncements contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub extern "C" fn NodeAnnouncement_clone(orig: &NodeAnnouncement) -> NodeAnnouncement {
orig.clone()
}
+/// Get a string which allows debug introspection of a NodeAnnouncement object
+pub extern "C" fn NodeAnnouncement_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::NodeAnnouncement }).into()}
+/// Generates a non-cryptographic 64-bit hash of the NodeAnnouncement.
+#[no_mangle]
+pub extern "C" fn NodeAnnouncement_hash(o: &NodeAnnouncement) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two NodeAnnouncements contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn UnsignedChannelAnnouncement_get_chain_hash(this_ptr: &UnsignedChannelAnnouncement) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain where the channel is to be opened
#[no_mangle]
pub extern "C" fn UnsignedChannelAnnouncement_set_chain_hash(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// The short channel ID
#[no_mangle]
let mut local_excess_data_arg = Vec::new(); for mut item in excess_data_arg.into_rust().drain(..) { local_excess_data_arg.push( { item }); };
UnsignedChannelAnnouncement { inner: ObjOps::heap_alloc(nativeUnsignedChannelAnnouncement {
features: *unsafe { Box::from_raw(features_arg.take_inner()) },
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
short_channel_id: short_channel_id_arg,
node_id_1: *unsafe { Box::from_raw(node_id_1_arg.take_inner()) },
node_id_2: *unsafe { Box::from_raw(node_id_2_arg.take_inner()) },
pub extern "C" fn UnsignedChannelAnnouncement_clone(orig: &UnsignedChannelAnnouncement) -> UnsignedChannelAnnouncement {
orig.clone()
}
+/// Get a string which allows debug introspection of a UnsignedChannelAnnouncement object
+pub extern "C" fn UnsignedChannelAnnouncement_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UnsignedChannelAnnouncement }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UnsignedChannelAnnouncement.
+#[no_mangle]
+pub extern "C" fn UnsignedChannelAnnouncement_hash(o: &UnsignedChannelAnnouncement) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two UnsignedChannelAnnouncements contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub extern "C" fn ChannelAnnouncement_clone(orig: &ChannelAnnouncement) -> ChannelAnnouncement {
orig.clone()
}
+/// Get a string which allows debug introspection of a ChannelAnnouncement object
+pub extern "C" fn ChannelAnnouncement_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ChannelAnnouncement }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ChannelAnnouncement.
+#[no_mangle]
+pub extern "C" fn ChannelAnnouncement_hash(o: &ChannelAnnouncement) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two ChannelAnnouncements contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn UnsignedChannelUpdate_get_chain_hash(this_ptr: &UnsignedChannelUpdate) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain where the channel is to be opened
#[no_mangle]
pub extern "C" fn UnsignedChannelUpdate_set_chain_hash(this_ptr: &mut UnsignedChannelUpdate, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// The short channel ID
#[no_mangle]
pub extern "C" fn UnsignedChannelUpdate_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut short_channel_id_arg: u64, mut timestamp_arg: u32, mut flags_arg: u8, mut cltv_expiry_delta_arg: u16, mut htlc_minimum_msat_arg: u64, mut htlc_maximum_msat_arg: u64, mut fee_base_msat_arg: u32, mut fee_proportional_millionths_arg: u32, mut excess_data_arg: crate::c_types::derived::CVec_u8Z) -> UnsignedChannelUpdate {
let mut local_excess_data_arg = Vec::new(); for mut item in excess_data_arg.into_rust().drain(..) { local_excess_data_arg.push( { item }); };
UnsignedChannelUpdate { inner: ObjOps::heap_alloc(nativeUnsignedChannelUpdate {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
short_channel_id: short_channel_id_arg,
timestamp: timestamp_arg,
flags: flags_arg,
pub extern "C" fn UnsignedChannelUpdate_clone(orig: &UnsignedChannelUpdate) -> UnsignedChannelUpdate {
orig.clone()
}
+/// Get a string which allows debug introspection of a UnsignedChannelUpdate object
+pub extern "C" fn UnsignedChannelUpdate_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::UnsignedChannelUpdate }).into()}
+/// Generates a non-cryptographic 64-bit hash of the UnsignedChannelUpdate.
+#[no_mangle]
+pub extern "C" fn UnsignedChannelUpdate_hash(o: &UnsignedChannelUpdate) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two UnsignedChannelUpdates contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub extern "C" fn ChannelUpdate_clone(orig: &ChannelUpdate) -> ChannelUpdate {
orig.clone()
}
+/// Get a string which allows debug introspection of a ChannelUpdate object
+pub extern "C" fn ChannelUpdate_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ChannelUpdate }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ChannelUpdate.
+#[no_mangle]
+pub extern "C" fn ChannelUpdate_hash(o: &ChannelUpdate) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two ChannelUpdates contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn QueryChannelRange_get_chain_hash(this_ptr: &QueryChannelRange) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain being queried
#[no_mangle]
pub extern "C" fn QueryChannelRange_set_chain_hash(this_ptr: &mut QueryChannelRange, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// The height of the first block for the channel UTXOs being queried
#[no_mangle]
#[no_mangle]
pub extern "C" fn QueryChannelRange_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut first_blocknum_arg: u32, mut number_of_blocks_arg: u32) -> QueryChannelRange {
QueryChannelRange { inner: ObjOps::heap_alloc(nativeQueryChannelRange {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
first_blocknum: first_blocknum_arg,
number_of_blocks: number_of_blocks_arg,
}), is_owned: true }
pub extern "C" fn QueryChannelRange_clone(orig: &QueryChannelRange) -> QueryChannelRange {
orig.clone()
}
+/// Get a string which allows debug introspection of a QueryChannelRange object
+pub extern "C" fn QueryChannelRange_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::QueryChannelRange }).into()}
+/// Generates a non-cryptographic 64-bit hash of the QueryChannelRange.
+#[no_mangle]
+pub extern "C" fn QueryChannelRange_hash(o: &QueryChannelRange) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two QueryChannelRanges contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn ReplyChannelRange_get_chain_hash(this_ptr: &ReplyChannelRange) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain being queried
#[no_mangle]
pub extern "C" fn ReplyChannelRange_set_chain_hash(this_ptr: &mut ReplyChannelRange, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// The height of the first block in the range of the reply
#[no_mangle]
pub extern "C" fn ReplyChannelRange_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut first_blocknum_arg: u32, mut number_of_blocks_arg: u32, mut sync_complete_arg: bool, mut short_channel_ids_arg: crate::c_types::derived::CVec_u64Z) -> ReplyChannelRange {
let mut local_short_channel_ids_arg = Vec::new(); for mut item in short_channel_ids_arg.into_rust().drain(..) { local_short_channel_ids_arg.push( { item }); };
ReplyChannelRange { inner: ObjOps::heap_alloc(nativeReplyChannelRange {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
first_blocknum: first_blocknum_arg,
number_of_blocks: number_of_blocks_arg,
sync_complete: sync_complete_arg,
pub extern "C" fn ReplyChannelRange_clone(orig: &ReplyChannelRange) -> ReplyChannelRange {
orig.clone()
}
+/// Get a string which allows debug introspection of a ReplyChannelRange object
+pub extern "C" fn ReplyChannelRange_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ReplyChannelRange }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ReplyChannelRange.
+#[no_mangle]
+pub extern "C" fn ReplyChannelRange_hash(o: &ReplyChannelRange) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two ReplyChannelRanges contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn QueryShortChannelIds_get_chain_hash(this_ptr: &QueryShortChannelIds) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain being queried
#[no_mangle]
pub extern "C" fn QueryShortChannelIds_set_chain_hash(this_ptr: &mut QueryShortChannelIds, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// The short_channel_ids that are being queried
///
pub extern "C" fn QueryShortChannelIds_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut short_channel_ids_arg: crate::c_types::derived::CVec_u64Z) -> QueryShortChannelIds {
let mut local_short_channel_ids_arg = Vec::new(); for mut item in short_channel_ids_arg.into_rust().drain(..) { local_short_channel_ids_arg.push( { item }); };
QueryShortChannelIds { inner: ObjOps::heap_alloc(nativeQueryShortChannelIds {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
short_channel_ids: local_short_channel_ids_arg,
}), is_owned: true }
}
pub extern "C" fn QueryShortChannelIds_clone(orig: &QueryShortChannelIds) -> QueryShortChannelIds {
orig.clone()
}
+/// Get a string which allows debug introspection of a QueryShortChannelIds object
+pub extern "C" fn QueryShortChannelIds_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::QueryShortChannelIds }).into()}
+/// Generates a non-cryptographic 64-bit hash of the QueryShortChannelIds.
+#[no_mangle]
+pub extern "C" fn QueryShortChannelIds_hash(o: &QueryShortChannelIds) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two QueryShortChannelIdss contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: &ReplyShortChannelIdsEnd) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain that was queried
#[no_mangle]
pub extern "C" fn ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: &mut ReplyShortChannelIdsEnd, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// Indicates if the query recipient maintains up-to-date channel
/// information for the `chain_hash`
#[no_mangle]
pub extern "C" fn ReplyShortChannelIdsEnd_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut full_information_arg: bool) -> ReplyShortChannelIdsEnd {
ReplyShortChannelIdsEnd { inner: ObjOps::heap_alloc(nativeReplyShortChannelIdsEnd {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
full_information: full_information_arg,
}), is_owned: true }
}
pub extern "C" fn ReplyShortChannelIdsEnd_clone(orig: &ReplyShortChannelIdsEnd) -> ReplyShortChannelIdsEnd {
orig.clone()
}
+/// Get a string which allows debug introspection of a ReplyShortChannelIdsEnd object
+pub extern "C" fn ReplyShortChannelIdsEnd_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ReplyShortChannelIdsEnd }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ReplyShortChannelIdsEnd.
+#[no_mangle]
+pub extern "C" fn ReplyShortChannelIdsEnd_hash(o: &ReplyShortChannelIdsEnd) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two ReplyShortChannelIdsEnds contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn GossipTimestampFilter_get_chain_hash(this_ptr: &GossipTimestampFilter) -> *const [u8; 32] {
let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
- inner_val.as_bytes()
+ inner_val.as_ref()
}
/// The genesis hash of the blockchain for channel and node information
#[no_mangle]
pub extern "C" fn GossipTimestampFilter_set_chain_hash(this_ptr: &mut GossipTimestampFilter, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data[..]);
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::blockdata::constants::ChainHash::from(&val.data);
}
/// The starting unix timestamp
#[no_mangle]
#[no_mangle]
pub extern "C" fn GossipTimestampFilter_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut first_timestamp_arg: u32, mut timestamp_range_arg: u32) -> GossipTimestampFilter {
GossipTimestampFilter { inner: ObjOps::heap_alloc(nativeGossipTimestampFilter {
- chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data[..]),
+ chain_hash: ::bitcoin::blockdata::constants::ChainHash::from(&chain_hash_arg.data),
first_timestamp: first_timestamp_arg,
timestamp_range: timestamp_range_arg,
}), is_owned: true }
pub extern "C" fn GossipTimestampFilter_clone(orig: &GossipTimestampFilter) -> GossipTimestampFilter {
orig.clone()
}
+/// Get a string which allows debug introspection of a GossipTimestampFilter object
+pub extern "C" fn GossipTimestampFilter_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::GossipTimestampFilter }).into()}
+/// Generates a non-cryptographic 64-bit hash of the GossipTimestampFilter.
+#[no_mangle]
+pub extern "C" fn GossipTimestampFilter_hash(o: &GossipTimestampFilter) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two GossipTimestampFilters contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeErrorAction) -> Self {
+ pub(crate) fn from_native(native: &ErrorActionImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeErrorAction) };
match native {
nativeErrorAction::DisconnectPeer {ref msg, } => {
let mut msg_nonref = Clone::clone(msg);
log_level,
}
}
+/// Get a string which allows debug introspection of a ErrorAction object
+pub extern "C" fn ErrorAction_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::ErrorAction }).into()}
+/// Generates a non-cryptographic 64-bit hash of the ErrorAction.
+#[no_mangle]
+pub extern "C" fn ErrorAction_hash(o: &ErrorAction) -> u64 {
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(&o.to_native(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
use lightning::ln::msgs::LightningError as nativeLightningErrorImport;
pub(crate) type nativeLightningError = nativeLightningErrorImport;
pub extern "C" fn LightningError_clone(orig: &LightningError) -> LightningError {
orig.clone()
}
+/// Get a string which allows debug introspection of a LightningError object
+pub extern "C" fn LightningError_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::LightningError }).into()}
use lightning::ln::msgs::CommitmentUpdate as nativeCommitmentUpdateImport;
pub(crate) type nativeCommitmentUpdate = nativeCommitmentUpdateImport;
pub extern "C" fn CommitmentUpdate_clone(orig: &CommitmentUpdate) -> CommitmentUpdate {
orig.clone()
}
+/// Get a string which allows debug introspection of a CommitmentUpdate object
+pub extern "C" fn CommitmentUpdate_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::CommitmentUpdate }).into()}
+/// Generates a non-cryptographic 64-bit hash of the CommitmentUpdate.
+#[no_mangle]
+pub extern "C" fn CommitmentUpdate_hash(o: &CommitmentUpdate) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
/// Checks if two CommitmentUpdates contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub handle_shutdown: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::Shutdown),
/// Handle an incoming `closing_signed` message from the given peer.
pub handle_closing_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::ClosingSigned),
+ /// Handle an incoming `stfu` message from the given peer.
+ pub handle_stfu: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::Stfu),
/// Handle an incoming `tx_add_input message` from the given peer.
pub handle_tx_add_input: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::TxAddInput),
/// Handle an incoming `tx_add_output` message from the given peer.
handle_channel_ready: Clone::clone(&orig.handle_channel_ready),
handle_shutdown: Clone::clone(&orig.handle_shutdown),
handle_closing_signed: Clone::clone(&orig.handle_closing_signed),
+ handle_stfu: Clone::clone(&orig.handle_stfu),
handle_tx_add_input: Clone::clone(&orig.handle_tx_add_input),
handle_tx_add_output: Clone::clone(&orig.handle_tx_add_output),
handle_tx_remove_input: Clone::clone(&orig.handle_tx_remove_input),
fn handle_closing_signed(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut msg: &lightning::ln::msgs::ClosingSigned) {
(self.handle_closing_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ClosingSigned { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ClosingSigned<>) as *mut _) }, is_owned: false })
}
+ fn handle_stfu(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut msg: &lightning::ln::msgs::Stfu) {
+ (self.handle_stfu)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Stfu { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::Stfu<>) as *mut _) }, is_owned: false })
+ }
fn handle_tx_add_input(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut msg: &lightning::ln::msgs::TxAddInput) {
(self.handle_tx_add_input)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::TxAddInput { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::TxAddInput<>) as *mut _) }, is_owned: false })
}
}
fn get_chain_hashes(&self) -> Option<Vec<bitcoin::blockdata::constants::ChainHash>> {
let mut ret = (self.get_chain_hashes)(self.this_arg);
- let mut local_ret = { /*ret*/ let ret_opt = ret; if ret_opt.is_none() { None } else { Some({ { let mut local_ret_0 = Vec::new(); for mut item in { ret_opt.take() }.into_rust().drain(..) { local_ret_0.push( { ::bitcoin::blockdata::constants::ChainHash::from(&item.data[..]) }); }; local_ret_0 }})} };
+ let mut local_ret = { /*ret*/ let ret_opt = ret; if ret_opt.is_none() { None } else { Some({ { let mut local_ret_0 = Vec::new(); for mut item in { ret_opt.take() }.into_rust().drain(..) { local_ret_0.push( { ::bitcoin::blockdata::constants::ChainHash::from(&item.data) }); }; local_ret_0 }})} };
local_ret
}
}
///
/// Note that this method is called before [`Self::peer_connected`].
pub provided_init_features: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::features::InitFeatures,
- /// Implementation of MessageSendEventsProvider for this object.
- pub MessageSendEventsProvider: crate::lightning::events::MessageSendEventsProvider,
+ /// Implementation of MessageSendEventsProvider for this object.
+ pub MessageSendEventsProvider: crate::lightning::events::MessageSendEventsProvider,
+ /// Frees any resources associated with this object given its this_arg pointer.
+ /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+ pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
+}
+unsafe impl Send for RoutingMessageHandler {}
+unsafe impl Sync for RoutingMessageHandler {}
+#[allow(unused)]
+pub(crate) fn RoutingMessageHandler_clone_fields(orig: &RoutingMessageHandler) -> RoutingMessageHandler {
+ RoutingMessageHandler {
+ this_arg: orig.this_arg,
+ handle_node_announcement: Clone::clone(&orig.handle_node_announcement),
+ handle_channel_announcement: Clone::clone(&orig.handle_channel_announcement),
+ handle_channel_update: Clone::clone(&orig.handle_channel_update),
+ get_next_channel_announcement: Clone::clone(&orig.get_next_channel_announcement),
+ get_next_node_announcement: Clone::clone(&orig.get_next_node_announcement),
+ peer_connected: Clone::clone(&orig.peer_connected),
+ handle_reply_channel_range: Clone::clone(&orig.handle_reply_channel_range),
+ handle_reply_short_channel_ids_end: Clone::clone(&orig.handle_reply_short_channel_ids_end),
+ handle_query_channel_range: Clone::clone(&orig.handle_query_channel_range),
+ handle_query_short_channel_ids: Clone::clone(&orig.handle_query_short_channel_ids),
+ processing_queue_high: Clone::clone(&orig.processing_queue_high),
+ provided_node_features: Clone::clone(&orig.provided_node_features),
+ provided_init_features: Clone::clone(&orig.provided_init_features),
+ MessageSendEventsProvider: crate::lightning::events::MessageSendEventsProvider_clone_fields(&orig.MessageSendEventsProvider),
+ free: Clone::clone(&orig.free),
+ }
+}
+impl lightning::events::MessageSendEventsProvider for RoutingMessageHandler {
+ fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::events::MessageSendEvent> {
+ let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.MessageSendEventsProvider.this_arg);
+ let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
+ local_ret
+ }
+}
+
+use lightning::ln::msgs::RoutingMessageHandler as rustRoutingMessageHandler;
+impl rustRoutingMessageHandler for RoutingMessageHandler {
+ fn handle_node_announcement(&self, mut msg: &lightning::ln::msgs::NodeAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
+ let mut ret = (self.handle_node_announcement)(self.this_arg, &crate::lightning::ln::msgs::NodeAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::NodeAnnouncement<>) as *mut _) }, is_owned: false });
+ 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, mut msg: &lightning::ln::msgs::ChannelAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
+ let mut ret = (self.handle_channel_announcement)(self.this_arg, &crate::lightning::ln::msgs::ChannelAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelAnnouncement<>) as *mut _) }, is_owned: false });
+ 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, mut msg: &lightning::ln::msgs::ChannelUpdate) -> Result<bool, lightning::ln::msgs::LightningError> {
+ let mut ret = (self.handle_channel_update)(self.this_arg, &crate::lightning::ln::msgs::ChannelUpdate { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelUpdate<>) as *mut _) }, is_owned: false });
+ 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 get_next_channel_announcement(&self, mut starting_point: u64) -> Option<(lightning::ln::msgs::ChannelAnnouncement, Option<lightning::ln::msgs::ChannelUpdate>, Option<lightning::ln::msgs::ChannelUpdate>)> {
+ let mut ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
+ let mut local_ret = if ret.is_some() { Some( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = ret.take().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 }) } else { None };
+ local_ret
+ }
+ fn get_next_node_announcement(&self, mut starting_point: Option<&lightning::routing::gossip::NodeId>) -> Option<lightning::ln::msgs::NodeAnnouncement> {
+ let mut local_starting_point = crate::lightning::routing::gossip::NodeId { inner: unsafe { (if starting_point.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (starting_point.unwrap()) }) } as *const lightning::routing::gossip::NodeId<>) as *mut _ }, is_owned: false };
+ let mut ret = (self.get_next_node_announcement)(self.this_arg, local_starting_point);
+ let mut local_ret = if ret.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(ret.take_inner()) } }) };
+ local_ret
+ }
+ fn peer_connected(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut init: &lightning::ln::msgs::Init, mut inbound: bool) -> Result<(), ()> {
+ let mut ret = (self.peer_connected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Init { inner: unsafe { ObjOps::nonnull_ptr_to_inner((init as *const lightning::ln::msgs::Init<>) as *mut _) }, is_owned: false }, inbound);
+ let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
+ local_ret
+ }
+ fn handle_reply_channel_range(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::ReplyChannelRange { inner: ObjOps::heap_alloc(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, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::ReplyShortChannelIdsEnd { inner: ObjOps::heap_alloc(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, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::QueryChannelRange { inner: ObjOps::heap_alloc(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, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::QueryShortChannelIds { inner: ObjOps::heap_alloc(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 processing_queue_high(&self) -> bool {
+ let mut ret = (self.processing_queue_high)(self.this_arg);
+ ret
+ }
+ fn provided_node_features(&self) -> lightning::ln::features::NodeFeatures {
+ let mut ret = (self.provided_node_features)(self.this_arg);
+ *unsafe { Box::from_raw(ret.take_inner()) }
+ }
+ fn provided_init_features(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey) -> lightning::ln::features::InitFeatures {
+ let mut ret = (self.provided_init_features)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id));
+ *unsafe { Box::from_raw(ret.take_inner()) }
+ }
+}
+
+// We're essentially a pointer already, or at least a set of pointers, so allow us to be used
+// directly as a Deref trait in higher-level structs:
+impl core::ops::Deref for RoutingMessageHandler {
+ type Target = Self;
+ fn deref(&self) -> &Self {
+ self
+ }
+}
+impl core::ops::DerefMut for RoutingMessageHandler {
+ fn deref_mut(&mut self) -> &mut Self {
+ self
+ }
+}
+/// Calls the free function if one is set
+#[no_mangle]
+pub extern "C" fn RoutingMessageHandler_free(this_ptr: RoutingMessageHandler) { }
+impl Drop for RoutingMessageHandler {
+ fn drop(&mut self) {
+ if let Some(f) = self.free {
+ f(self.this_arg);
+ }
+ }
+}
+/// A handler for received [`OnionMessage`]s and for providing generated ones to send.
+#[repr(C)]
+pub struct OnionMessageHandler {
+ /// An opaque pointer which is passed to your function implementations as an argument.
+ /// This has no meaning in the LDK, and can be NULL or any other value.
+ pub this_arg: *mut c_void,
+ /// Because much of the lightning network does not yet support forwarding onion messages, we
+ /// may need to directly connect to a node which will forward a message for us. In such a case,
+ /// this method will return the set of nodes which need connection by node_id and the
+ /// corresponding socket addresses where they may accept incoming connections.
+ ///
+ /// Thus, this method should be polled regularly to detect messages await such a direct
+ /// connection.
+ pub get_and_clear_connections_needed: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ,
+ /// Handle an incoming `onion_message` message from the given peer.
+ pub handle_onion_message: extern "C" fn (this_arg: *const c_void, peer_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::OnionMessage),
+ /// Returns the next pending onion message for the peer with the given node id.
+ ///
+ /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ pub next_onion_message_for_peer: extern "C" fn (this_arg: *const c_void, peer_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::msgs::OnionMessage,
+ /// Called when a connection is established with a peer. Can be used to track which peers
+ /// advertise onion message support and are online.
+ ///
+ /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ /// with us. Implementors should be somewhat conservative about doing so, however, as other
+ /// message handlers may still wish to communicate with this peer.
+ pub peer_connected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, init: &crate::lightning::ln::msgs::Init, inbound: bool) -> crate::c_types::derived::CResult_NoneNoneZ,
+ /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
+ /// drop and refuse to forward onion messages to this peer.
+ pub peer_disconnected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey),
+ /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
+ /// to drop any buffered onion messages intended for prospective peers.
+ pub timer_tick_occurred: extern "C" fn (this_arg: *const c_void),
+ /// Gets the node feature flags which this handler itself supports. All available handlers are
+ /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ /// which are broadcasted in our [`NodeAnnouncement`] message.
+ pub provided_node_features: extern "C" fn (this_arg: *const c_void) -> crate::lightning::ln::features::NodeFeatures,
+ /// Gets the init feature flags which should be sent to the given peer. All available handlers
+ /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ /// which are sent in our [`Init`] message.
+ ///
+ /// Note that this method is called before [`Self::peer_connected`].
+ pub provided_init_features: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::features::InitFeatures,
/// Frees any resources associated with this object given its this_arg pointer.
/// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
}
-unsafe impl Send for RoutingMessageHandler {}
-unsafe impl Sync for RoutingMessageHandler {}
+unsafe impl Send for OnionMessageHandler {}
+unsafe impl Sync for OnionMessageHandler {}
#[allow(unused)]
-pub(crate) fn RoutingMessageHandler_clone_fields(orig: &RoutingMessageHandler) -> RoutingMessageHandler {
- RoutingMessageHandler {
+pub(crate) fn OnionMessageHandler_clone_fields(orig: &OnionMessageHandler) -> OnionMessageHandler {
+ OnionMessageHandler {
this_arg: orig.this_arg,
- handle_node_announcement: Clone::clone(&orig.handle_node_announcement),
- handle_channel_announcement: Clone::clone(&orig.handle_channel_announcement),
- handle_channel_update: Clone::clone(&orig.handle_channel_update),
- get_next_channel_announcement: Clone::clone(&orig.get_next_channel_announcement),
- get_next_node_announcement: Clone::clone(&orig.get_next_node_announcement),
+ get_and_clear_connections_needed: Clone::clone(&orig.get_and_clear_connections_needed),
+ handle_onion_message: Clone::clone(&orig.handle_onion_message),
+ next_onion_message_for_peer: Clone::clone(&orig.next_onion_message_for_peer),
peer_connected: Clone::clone(&orig.peer_connected),
- handle_reply_channel_range: Clone::clone(&orig.handle_reply_channel_range),
- handle_reply_short_channel_ids_end: Clone::clone(&orig.handle_reply_short_channel_ids_end),
- handle_query_channel_range: Clone::clone(&orig.handle_query_channel_range),
- handle_query_short_channel_ids: Clone::clone(&orig.handle_query_short_channel_ids),
- processing_queue_high: Clone::clone(&orig.processing_queue_high),
+ peer_disconnected: Clone::clone(&orig.peer_disconnected),
+ timer_tick_occurred: Clone::clone(&orig.timer_tick_occurred),
provided_node_features: Clone::clone(&orig.provided_node_features),
provided_init_features: Clone::clone(&orig.provided_init_features),
- MessageSendEventsProvider: crate::lightning::events::MessageSendEventsProvider_clone_fields(&orig.MessageSendEventsProvider),
free: Clone::clone(&orig.free),
}
}
-impl lightning::events::MessageSendEventsProvider for RoutingMessageHandler {
- fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::events::MessageSendEvent> {
- let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.MessageSendEventsProvider.this_arg);
- let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
- local_ret
- }
-}
-use lightning::ln::msgs::RoutingMessageHandler as rustRoutingMessageHandler;
-impl rustRoutingMessageHandler for RoutingMessageHandler {
- fn handle_node_announcement(&self, mut msg: &lightning::ln::msgs::NodeAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
- let mut ret = (self.handle_node_announcement)(self.this_arg, &crate::lightning::ln::msgs::NodeAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::NodeAnnouncement<>) as *mut _) }, is_owned: false });
- 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, mut msg: &lightning::ln::msgs::ChannelAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
- let mut ret = (self.handle_channel_announcement)(self.this_arg, &crate::lightning::ln::msgs::ChannelAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelAnnouncement<>) as *mut _) }, is_owned: false });
- 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, mut msg: &lightning::ln::msgs::ChannelUpdate) -> Result<bool, lightning::ln::msgs::LightningError> {
- let mut ret = (self.handle_channel_update)(self.this_arg, &crate::lightning::ln::msgs::ChannelUpdate { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelUpdate<>) as *mut _) }, is_owned: false });
- 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()) } })};
+use lightning::ln::msgs::OnionMessageHandler as rustOnionMessageHandler;
+impl rustOnionMessageHandler for OnionMessageHandler {
+ fn get_and_clear_connections_needed(&self) -> Vec<(bitcoin::secp256k1::PublicKey, Vec<lightning::ln::msgs::SocketAddress>)> {
+ let mut ret = (self.get_and_clear_connections_needed)(self.this_arg);
+ 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) = item.to_rust(); let mut local_orig_ret_0_1 = Vec::new(); for mut item in orig_ret_0_1.into_rust().drain(..) { local_orig_ret_0_1.push( { item.into_native() }); }; let mut local_ret_0 = (orig_ret_0_0.into_rust(), local_orig_ret_0_1); local_ret_0 }); };
local_ret
}
- fn get_next_channel_announcement(&self, mut starting_point: u64) -> Option<(lightning::ln::msgs::ChannelAnnouncement, Option<lightning::ln::msgs::ChannelUpdate>, Option<lightning::ln::msgs::ChannelUpdate>)> {
- let mut ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
- let mut local_ret = if ret.is_some() { Some( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = ret.take().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 }) } else { None };
- local_ret
+ fn handle_onion_message(&self, mut peer_node_id: &bitcoin::secp256k1::PublicKey, mut msg: &lightning::ln::msgs::OnionMessage) {
+ (self.handle_onion_message)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id), &crate::lightning::ln::msgs::OnionMessage { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::OnionMessage<>) as *mut _) }, is_owned: false })
}
- fn get_next_node_announcement(&self, mut starting_point: Option<&lightning::routing::gossip::NodeId>) -> Option<lightning::ln::msgs::NodeAnnouncement> {
- let mut local_starting_point = crate::lightning::routing::gossip::NodeId { inner: unsafe { (if starting_point.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (starting_point.unwrap()) }) } as *const lightning::routing::gossip::NodeId<>) as *mut _ }, is_owned: false };
- let mut ret = (self.get_next_node_announcement)(self.this_arg, local_starting_point);
+ fn next_onion_message_for_peer(&self, mut peer_node_id: bitcoin::secp256k1::PublicKey) -> Option<lightning::ln::msgs::OnionMessage> {
+ let mut ret = (self.next_onion_message_for_peer)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id));
let mut local_ret = if ret.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(ret.take_inner()) } }) };
local_ret
}
let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
local_ret
}
- fn handle_reply_channel_range(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::ReplyChannelRange { inner: ObjOps::heap_alloc(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, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::ReplyShortChannelIdsEnd { inner: ObjOps::heap_alloc(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, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::QueryChannelRange { inner: ObjOps::heap_alloc(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, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut 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::lightning::ln::msgs::QueryShortChannelIds { inner: ObjOps::heap_alloc(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 peer_disconnected(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey) {
+ (self.peer_disconnected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id))
}
- fn processing_queue_high(&self) -> bool {
- let mut ret = (self.processing_queue_high)(self.this_arg);
- ret
+ fn timer_tick_occurred(&self) {
+ (self.timer_tick_occurred)(self.this_arg)
}
fn provided_node_features(&self) -> lightning::ln::features::NodeFeatures {
let mut ret = (self.provided_node_features)(self.this_arg);
*unsafe { Box::from_raw(ret.take_inner()) }
}
}
-
-// We're essentially a pointer already, or at least a set of pointers, so allow us to be used
-// directly as a Deref trait in higher-level structs:
-impl core::ops::Deref for RoutingMessageHandler {
- type Target = Self;
- fn deref(&self) -> &Self {
- self
- }
+
+// We're essentially a pointer already, or at least a set of pointers, so allow us to be used
+// directly as a Deref trait in higher-level structs:
+impl core::ops::Deref for OnionMessageHandler {
+ type Target = Self;
+ fn deref(&self) -> &Self {
+ self
+ }
+}
+impl core::ops::DerefMut for OnionMessageHandler {
+ fn deref_mut(&mut self) -> &mut Self {
+ self
+ }
+}
+/// Calls the free function if one is set
+#[no_mangle]
+pub extern "C" fn OnionMessageHandler_free(this_ptr: OnionMessageHandler) { }
+impl Drop for OnionMessageHandler {
+ fn drop(&mut self) {
+ if let Some(f) = self.free {
+ f(self.this_arg);
+ }
+ }
+}
+
+use lightning::ln::msgs::FinalOnionHopData as nativeFinalOnionHopDataImport;
+pub(crate) type nativeFinalOnionHopData = nativeFinalOnionHopDataImport;
+
+/// Information communicated in the onion to the recipient for multi-part tracking and proof that
+/// the payment is associated with an invoice.
+#[must_use]
+#[repr(C)]
+pub struct FinalOnionHopData {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeFinalOnionHopData,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for FinalOnionHopData {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeFinalOnionHopData>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the FinalOnionHopData, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn FinalOnionHopData_free(this_obj: FinalOnionHopData) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn FinalOnionHopData_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeFinalOnionHopData) };
+}
+#[allow(unused)]
+impl FinalOnionHopData {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeFinalOnionHopData {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeFinalOnionHopData {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeFinalOnionHopData {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
+/// Because it is generated by the recipient and included in the invoice, it also provides
+/// proof to the recipient that the payment was sent by someone with the generated invoice.
+#[no_mangle]
+pub extern "C" fn FinalOnionHopData_get_payment_secret(this_ptr: &FinalOnionHopData) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_secret;
+ &inner_val.0
+}
+/// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
+/// Because it is generated by the recipient and included in the invoice, it also provides
+/// proof to the recipient that the payment was sent by someone with the generated invoice.
+#[no_mangle]
+pub extern "C" fn FinalOnionHopData_set_payment_secret(this_ptr: &mut FinalOnionHopData, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_secret = ::lightning::ln::types::PaymentSecret(val.data);
+}
+/// The intended total amount that this payment is for.
+///
+/// Message serialization may panic if this value is more than 21 million Bitcoin.
+#[no_mangle]
+pub extern "C" fn FinalOnionHopData_get_total_msat(this_ptr: &FinalOnionHopData) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().total_msat;
+ *inner_val
+}
+/// The intended total amount that this payment is for.
+///
+/// Message serialization may panic if this value is more than 21 million Bitcoin.
+#[no_mangle]
+pub extern "C" fn FinalOnionHopData_set_total_msat(this_ptr: &mut FinalOnionHopData, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.total_msat = val;
+}
+/// Constructs a new FinalOnionHopData given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn FinalOnionHopData_new(mut payment_secret_arg: crate::c_types::ThirtyTwoBytes, mut total_msat_arg: u64) -> FinalOnionHopData {
+ FinalOnionHopData { inner: ObjOps::heap_alloc(nativeFinalOnionHopData {
+ payment_secret: ::lightning::ln::types::PaymentSecret(payment_secret_arg.data),
+ total_msat: total_msat_arg,
+ }), is_owned: true }
+}
+impl Clone for FinalOnionHopData {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeFinalOnionHopData>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 FinalOnionHopData_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeFinalOnionHopData)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the FinalOnionHopData
+pub extern "C" fn FinalOnionHopData_clone(orig: &FinalOnionHopData) -> FinalOnionHopData {
+ orig.clone()
+}
+mod fuzzy_internal_msgs {
+
+use alloc::str::FromStr;
+use alloc::string::String;
+use core::ffi::c_void;
+use core::convert::Infallible;
+use bitcoin::hashes::Hash;
+use crate::c_types::*;
+#[cfg(feature="no-std")]
+use alloc::{vec::Vec, boxed::Box};
+
+}
+
+use lightning::ln::msgs::OnionPacket as nativeOnionPacketImport;
+pub(crate) type nativeOnionPacket = nativeOnionPacketImport;
+
+/// BOLT 4 onion packet including hop data for the next peer.
+#[must_use]
+#[repr(C)]
+pub struct OnionPacket {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeOnionPacket,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for OnionPacket {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativeOnionPacket>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the OnionPacket, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn OnionPacket_free(this_obj: OnionPacket) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn OnionPacket_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeOnionPacket) };
+}
+#[allow(unused)]
+impl OnionPacket {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeOnionPacket {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeOnionPacket {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeOnionPacket {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+}
+/// BOLT 4 version number.
+#[no_mangle]
+pub extern "C" fn OnionPacket_get_version(this_ptr: &OnionPacket) -> u8 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().version;
+ *inner_val
+}
+/// BOLT 4 version number.
+#[no_mangle]
+pub extern "C" fn OnionPacket_set_version(this_ptr: &mut OnionPacket, mut val: u8) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.version = val;
+}
+/// In order to ensure we always return an error on onion decode in compliance with [BOLT
+/// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
+/// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
+/// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
+/// like.
+///
+/// Returns a copy of the field.
+#[no_mangle]
+pub extern "C" fn OnionPacket_get_public_key(this_ptr: &OnionPacket) -> crate::c_types::derived::CResult_PublicKeySecp256k1ErrorZ {
+ let mut inner_val = this_ptr.get_native_mut_ref().public_key.clone();
+ let mut local_inner_val = match inner_val { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::PublicKey::from_rust(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }).into() };
+ local_inner_val
+}
+/// In order to ensure we always return an error on onion decode in compliance with [BOLT
+/// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
+/// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
+/// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
+/// like.
+#[no_mangle]
+pub extern "C" fn OnionPacket_set_public_key(this_ptr: &mut OnionPacket, mut val: crate::c_types::derived::CResult_PublicKeySecp256k1ErrorZ) {
+ let mut local_val = match val.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut val.contents.result)) }).into_rust() }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut val.contents.err)) }).into_rust() })};
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.public_key = local_val;
+}
+/// HMAC to verify the integrity of hop_data.
+#[no_mangle]
+pub extern "C" fn OnionPacket_get_hmac(this_ptr: &OnionPacket) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().hmac;
+ inner_val
+}
+/// HMAC to verify the integrity of hop_data.
+#[no_mangle]
+pub extern "C" fn OnionPacket_set_hmac(this_ptr: &mut OnionPacket, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.hmac = val.data;
+}
+impl Clone for OnionPacket {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeOnionPacket>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(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 OnionPacket_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeOnionPacket)).clone() })) as *mut c_void
}
-impl core::ops::DerefMut for RoutingMessageHandler {
- fn deref_mut(&mut self) -> &mut Self {
- self
- }
+#[no_mangle]
+/// Creates a copy of the OnionPacket
+pub extern "C" fn OnionPacket_clone(orig: &OnionPacket) -> OnionPacket {
+ orig.clone()
}
-/// Calls the free function if one is set
+/// Generates a non-cryptographic 64-bit hash of the OnionPacket.
#[no_mangle]
-pub extern "C" fn RoutingMessageHandler_free(this_ptr: RoutingMessageHandler) { }
-impl Drop for RoutingMessageHandler {
+pub extern "C" fn OnionPacket_hash(o: &OnionPacket) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two OnionPackets contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn OnionPacket_eq(a: &OnionPacket, b: &OnionPacket) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+/// Get a string which allows debug introspection of a OnionPacket object
+pub extern "C" fn OnionPacket_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::OnionPacket }).into()}
+
+use lightning::ln::msgs::TrampolineOnionPacket as nativeTrampolineOnionPacketImport;
+pub(crate) type nativeTrampolineOnionPacket = nativeTrampolineOnionPacketImport;
+
+/// BOLT 4 onion packet including hop data for the next peer.
+#[must_use]
+#[repr(C)]
+pub struct TrampolineOnionPacket {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativeTrampolineOnionPacket,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl Drop for TrampolineOnionPacket {
fn drop(&mut self) {
- if let Some(f) = self.free {
- f(self.this_arg);
+ if self.is_owned && !<*mut nativeTrampolineOnionPacket>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
}
}
}
-/// A handler for received [`OnionMessage`]s and for providing generated ones to send.
-#[repr(C)]
-pub struct OnionMessageHandler {
- /// An opaque pointer which is passed to your function implementations as an argument.
- /// This has no meaning in the LDK, and can be NULL or any other value.
- pub this_arg: *mut c_void,
- /// Handle an incoming `onion_message` message from the given peer.
- pub handle_onion_message: extern "C" fn (this_arg: *const c_void, peer_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::OnionMessage),
- /// Returns the next pending onion message for the peer with the given node id.
- ///
- /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
- pub next_onion_message_for_peer: extern "C" fn (this_arg: *const c_void, peer_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::msgs::OnionMessage,
- /// Called when a connection is established with a peer. Can be used to track which peers
- /// advertise onion message support and are online.
- ///
- /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
- /// with us. Implementors should be somewhat conservative about doing so, however, as other
- /// message handlers may still wish to communicate with this peer.
- pub peer_connected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, init: &crate::lightning::ln::msgs::Init, inbound: bool) -> crate::c_types::derived::CResult_NoneNoneZ,
- /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
- /// drop and refuse to forward onion messages to this peer.
- pub peer_disconnected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey),
- /// Gets the node feature flags which this handler itself supports. All available handlers are
- /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
- /// which are broadcasted in our [`NodeAnnouncement`] message.
- pub provided_node_features: extern "C" fn (this_arg: *const c_void) -> crate::lightning::ln::features::NodeFeatures,
- /// Gets the init feature flags which should be sent to the given peer. All available handlers
- /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
- /// which are sent in our [`Init`] message.
- ///
- /// Note that this method is called before [`Self::peer_connected`].
- pub provided_init_features: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::features::InitFeatures,
- /// Frees any resources associated with this object given its this_arg pointer.
- /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
- pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
-}
-unsafe impl Send for OnionMessageHandler {}
-unsafe impl Sync for OnionMessageHandler {}
+/// Frees any resources used by the TrampolineOnionPacket, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_free(this_obj: TrampolineOnionPacket) { }
#[allow(unused)]
-pub(crate) fn OnionMessageHandler_clone_fields(orig: &OnionMessageHandler) -> OnionMessageHandler {
- OnionMessageHandler {
- this_arg: orig.this_arg,
- handle_onion_message: Clone::clone(&orig.handle_onion_message),
- next_onion_message_for_peer: Clone::clone(&orig.next_onion_message_for_peer),
- peer_connected: Clone::clone(&orig.peer_connected),
- peer_disconnected: Clone::clone(&orig.peer_disconnected),
- provided_node_features: Clone::clone(&orig.provided_node_features),
- provided_init_features: Clone::clone(&orig.provided_init_features),
- free: Clone::clone(&orig.free),
- }
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn TrampolineOnionPacket_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativeTrampolineOnionPacket) };
}
-
-use lightning::ln::msgs::OnionMessageHandler as rustOnionMessageHandler;
-impl rustOnionMessageHandler for OnionMessageHandler {
- fn handle_onion_message(&self, mut peer_node_id: &bitcoin::secp256k1::PublicKey, mut msg: &lightning::ln::msgs::OnionMessage) {
- (self.handle_onion_message)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id), &crate::lightning::ln::msgs::OnionMessage { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::OnionMessage<>) as *mut _) }, is_owned: false })
- }
- fn next_onion_message_for_peer(&self, mut peer_node_id: bitcoin::secp256k1::PublicKey) -> Option<lightning::ln::msgs::OnionMessage> {
- let mut ret = (self.next_onion_message_for_peer)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id));
- let mut local_ret = if ret.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(ret.take_inner()) } }) };
- local_ret
- }
- fn peer_connected(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey, mut init: &lightning::ln::msgs::Init, mut inbound: bool) -> Result<(), ()> {
- let mut ret = (self.peer_connected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Init { inner: unsafe { ObjOps::nonnull_ptr_to_inner((init as *const lightning::ln::msgs::Init<>) as *mut _) }, is_owned: false }, inbound);
- let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
- local_ret
- }
- fn peer_disconnected(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey) {
- (self.peer_disconnected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id))
+#[allow(unused)]
+impl TrampolineOnionPacket {
+ pub(crate) fn get_native_ref(&self) -> &'static nativeTrampolineOnionPacket {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
}
- fn provided_node_features(&self) -> lightning::ln::features::NodeFeatures {
- let mut ret = (self.provided_node_features)(self.this_arg);
- *unsafe { Box::from_raw(ret.take_inner()) }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeTrampolineOnionPacket {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
}
- fn provided_init_features(&self, mut their_node_id: &bitcoin::secp256k1::PublicKey) -> lightning::ln::features::InitFeatures {
- let mut ret = (self.provided_init_features)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id));
- *unsafe { Box::from_raw(ret.take_inner()) }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativeTrampolineOnionPacket {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
}
}
-
-// We're essentially a pointer already, or at least a set of pointers, so allow us to be used
-// directly as a Deref trait in higher-level structs:
-impl core::ops::Deref for OnionMessageHandler {
- type Target = Self;
- fn deref(&self) -> &Self {
- self
- }
+/// Bolt 04 version number
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_get_version(this_ptr: &TrampolineOnionPacket) -> u8 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().version;
+ *inner_val
}
-impl core::ops::DerefMut for OnionMessageHandler {
- fn deref_mut(&mut self) -> &mut Self {
- self
- }
+/// Bolt 04 version number
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_set_version(this_ptr: &mut TrampolineOnionPacket, mut val: u8) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.version = val;
}
-/// Calls the free function if one is set
+/// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
#[no_mangle]
-pub extern "C" fn OnionMessageHandler_free(this_ptr: OnionMessageHandler) { }
-impl Drop for OnionMessageHandler {
- fn drop(&mut self) {
- if let Some(f) = self.free {
- f(self.this_arg);
+pub extern "C" fn TrampolineOnionPacket_get_public_key(this_ptr: &TrampolineOnionPacket) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().public_key;
+ crate::c_types::PublicKey::from_rust(&inner_val)
+}
+/// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_set_public_key(this_ptr: &mut TrampolineOnionPacket, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.public_key = val.into_rust();
+}
+/// Encrypted payload for the next hop
+///
+/// Returns a copy of the field.
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_get_hop_data(this_ptr: &TrampolineOnionPacket) -> crate::c_types::derived::CVec_u8Z {
+ let mut inner_val = this_ptr.get_native_mut_ref().hop_data.clone();
+ let mut local_inner_val = Vec::new(); for mut item in inner_val.drain(..) { local_inner_val.push( { item }); };
+ local_inner_val.into()
+}
+/// Encrypted payload for the next hop
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_set_hop_data(this_ptr: &mut TrampolineOnionPacket, mut val: crate::c_types::derived::CVec_u8Z) {
+ let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.hop_data = local_val;
+}
+/// HMAC to verify the integrity of hop_data
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_get_hmac(this_ptr: &TrampolineOnionPacket) -> *const [u8; 32] {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().hmac;
+ inner_val
+}
+/// HMAC to verify the integrity of hop_data
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_set_hmac(this_ptr: &mut TrampolineOnionPacket, mut val: crate::c_types::ThirtyTwoBytes) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.hmac = val.data;
+}
+/// Constructs a new TrampolineOnionPacket given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_new(mut version_arg: u8, mut public_key_arg: crate::c_types::PublicKey, mut hop_data_arg: crate::c_types::derived::CVec_u8Z, mut hmac_arg: crate::c_types::ThirtyTwoBytes) -> TrampolineOnionPacket {
+ let mut local_hop_data_arg = Vec::new(); for mut item in hop_data_arg.into_rust().drain(..) { local_hop_data_arg.push( { item }); };
+ TrampolineOnionPacket { inner: ObjOps::heap_alloc(nativeTrampolineOnionPacket {
+ version: version_arg,
+ public_key: public_key_arg.into_rust(),
+ hop_data: local_hop_data_arg,
+ hmac: hmac_arg.data,
+ }), is_owned: true }
+}
+impl Clone for TrampolineOnionPacket {
+ fn clone(&self) -> Self {
+ Self {
+ inner: if <*mut nativeTrampolineOnionPacket>::is_null(self.inner) { core::ptr::null_mut() } else {
+ ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
+ is_owned: true,
}
}
}
-mod fuzzy_internal_msgs {
-
-use alloc::str::FromStr;
-use alloc::string::String;
-use core::ffi::c_void;
-use core::convert::Infallible;
-use bitcoin::hashes::Hash;
-use crate::c_types::*;
-#[cfg(feature="no-std")]
-use alloc::{vec::Vec, boxed::Box};
-
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn TrampolineOnionPacket_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeTrampolineOnionPacket)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the TrampolineOnionPacket
+pub extern "C" fn TrampolineOnionPacket_clone(orig: &TrampolineOnionPacket) -> TrampolineOnionPacket {
+ orig.clone()
+}
+/// Generates a non-cryptographic 64-bit hash of the TrampolineOnionPacket.
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_hash(o: &TrampolineOnionPacket) -> u64 {
+ if o.inner.is_null() { return 0; }
+ // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
+ #[allow(deprecated)]
+ let mut hasher = core::hash::SipHasher::new();
+ core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
+ core::hash::Hasher::finish(&hasher)
+}
+/// Checks if two TrampolineOnionPackets contain equal inner contents.
+/// This ignores pointers and is_owned flags and looks at the values in fields.
+/// Two objects with NULL inner values will be considered "equal" here.
+#[no_mangle]
+pub extern "C" fn TrampolineOnionPacket_eq(a: &TrampolineOnionPacket, b: &TrampolineOnionPacket) -> bool {
+ if a.inner == b.inner { return true; }
+ if a.inner.is_null() || b.inner.is_null() { return false; }
+ if a.get_native_ref() == b.get_native_ref() { true } else { false }
+}
+#[no_mangle]
+/// Serialize the TrampolineOnionPacket object into a byte array which can be read by TrampolineOnionPacket_read
+pub extern "C" fn TrampolineOnionPacket_write(obj: &crate::lightning::ln::msgs::TrampolineOnionPacket) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn TrampolineOnionPacket_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeTrampolineOnionPacket) })
+}
+/// Get a string which allows debug introspection of a TrampolineOnionPacket object
+pub extern "C" fn TrampolineOnionPacket_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::ln::msgs::TrampolineOnionPacket }).into()}
+#[no_mangle]
+/// Get the string representation of a DecodeError object
+pub extern "C" fn DecodeError_to_str(o: &crate::lightning::ln::msgs::DecodeError) -> Str {
+ alloc::format!("{}", &o.to_native()).into()
}
#[no_mangle]
/// Serialize the AcceptChannel object into a byte array which can be read by AcceptChannel_read
local_res
}
#[no_mangle]
+/// Serialize the Stfu object into a byte array which can be read by Stfu_read
+pub extern "C" fn Stfu_write(obj: &crate::lightning::ln::msgs::Stfu) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn Stfu_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeStfu) })
+}
+#[no_mangle]
+/// Read a Stfu from a byte array, created by Stfu_write
+pub extern "C" fn Stfu_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_StfuDecodeErrorZ {
+ let res: Result<lightning::ln::msgs::Stfu, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Stfu { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
+ local_res
+}
+#[no_mangle]
+/// Serialize the Splice object into a byte array which can be read by Splice_read
+pub extern "C" fn Splice_write(obj: &crate::lightning::ln::msgs::Splice) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn Splice_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeSplice) })
+}
+#[no_mangle]
+/// Read a Splice from a byte array, created by Splice_write
+pub extern "C" fn Splice_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SpliceDecodeErrorZ {
+ let res: Result<lightning::ln::msgs::Splice, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Splice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
+ local_res
+}
+#[no_mangle]
+/// Serialize the SpliceAck object into a byte array which can be read by SpliceAck_read
+pub extern "C" fn SpliceAck_write(obj: &crate::lightning::ln::msgs::SpliceAck) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn SpliceAck_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeSpliceAck) })
+}
+#[no_mangle]
+/// Read a SpliceAck from a byte array, created by SpliceAck_write
+pub extern "C" fn SpliceAck_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SpliceAckDecodeErrorZ {
+ let res: Result<lightning::ln::msgs::SpliceAck, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::SpliceAck { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
+ local_res
+}
+#[no_mangle]
+/// Serialize the SpliceLocked object into a byte array which can be read by SpliceLocked_read
+pub extern "C" fn SpliceLocked_write(obj: &crate::lightning::ln::msgs::SpliceLocked) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn SpliceLocked_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeSpliceLocked) })
+}
+#[no_mangle]
+/// Read a SpliceLocked from a byte array, created by SpliceLocked_write
+pub extern "C" fn SpliceLocked_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SpliceLockedDecodeErrorZ {
+ let res: Result<lightning::ln::msgs::SpliceLocked, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::SpliceLocked { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
+ local_res
+}
+#[no_mangle]
/// Serialize the TxAddInput object into a byte array which can be read by TxAddInput_read
pub extern "C" fn TxAddInput_write(obj: &crate::lightning::ln::msgs::TxAddInput) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
local_res
}
#[no_mangle]
+/// Serialize the OnionPacket object into a byte array which can be read by OnionPacket_read
+pub extern "C" fn OnionPacket_write(obj: &crate::lightning::ln::msgs::OnionPacket) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn OnionPacket_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeOnionPacket) })
+}
+#[no_mangle]
+/// Read a OnionPacket from a byte array, created by OnionPacket_write
+pub extern "C" fn OnionPacket_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_OnionPacketDecodeErrorZ {
+ let res: Result<lightning::ln::msgs::OnionPacket, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::OnionPacket { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
+ local_res
+}
+#[no_mangle]
/// Serialize the UpdateAddHTLC object into a byte array which can be read by UpdateAddHTLC_read
pub extern "C" fn UpdateAddHTLC_write(obj: &crate::lightning::ln::msgs::UpdateAddHTLC) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeOnionMessage) })
}
#[no_mangle]
+/// Serialize the FinalOnionHopData object into a byte array which can be read by FinalOnionHopData_read
+pub extern "C" fn FinalOnionHopData_write(obj: &crate::lightning::ln::msgs::FinalOnionHopData) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[allow(unused)]
+pub(crate) extern "C" fn FinalOnionHopData_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFinalOnionHopData) })
+}
+#[no_mangle]
+/// Read a FinalOnionHopData from a byte array, created by FinalOnionHopData_write
+pub extern "C" fn FinalOnionHopData_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FinalOnionHopDataDecodeErrorZ {
+ let res: Result<lightning::ln::msgs::FinalOnionHopData, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FinalOnionHopData { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
+ local_res
+}
+#[no_mangle]
/// Serialize the Ping object into a byte array which can be read by Ping_read
pub extern "C" fn Ping_write(obj: &crate::lightning::ln::msgs::Ping) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())