X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning_invoice%2Fmod.rs;h=6fb6248fc02b631a75d2f7b859a5c09becf978c3;hb=82601052fe2cac04a6249f5930495e987923303b;hp=760da327713da2aafe6e3373e88ee873391703c9;hpb=fa53bccc47204dba265106ed70c796f8e20109a1;p=ldk-c-bindings diff --git a/lightning-c-bindings/src/lightning_invoice/mod.rs b/lightning-c-bindings/src/lightning_invoice/mod.rs index 760da32..6fb6248 100644 --- a/lightning-c-bindings/src/lightning_invoice/mod.rs +++ b/lightning-c-bindings/src/lightning_invoice/mod.rs @@ -7,13 +7,15 @@ // source was automatically generated. //! This crate provides data structures to represent -//! [lightning BOLT11](https://github.com/lightningnetwork/lightning-rfc/blob/master/11-payment-encoding.md) +//! [lightning BOLT11](https://github.com/lightning/bolts/blob/master/11-payment-encoding.md) //! invoices and functions to create, encode and decode these. If you just want to use the standard //! en-/decoding functionality this should get you started: //! -//! * For parsing use `str::parse::(&self)` (see the docs of `impl FromStr for Invoice`) -//! * For constructing invoices use the `InvoiceBuilder` -//! * For serializing invoices use the `Display`/`ToString` traits +//! * For parsing use `str::parse::(&self)` (see [`Invoice::from_str`]) +//! * For constructing invoices use the [`InvoiceBuilder`] +//! * For serializing invoices use the [`Display`]/[`ToString`] traits +//! +//! [`Invoice::from_str`]: crate::Invoice#impl-FromStr use alloc::str::FromStr; use core::ffi::c_void; @@ -26,6 +28,17 @@ use alloc::{vec::Vec, boxed::Box}; pub mod payment; pub mod utils; pub mod constants; +mod time_utils { + +use alloc::str::FromStr; +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}; + +} mod de { use alloc::str::FromStr; @@ -49,40 +62,62 @@ use alloc::{vec::Vec, boxed::Box}; } #[no_mangle] /// Read a SiPrefix object from a string -pub extern "C" fn SiPrefix_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SiPrefixNoneZ { +pub extern "C" fn SiPrefix_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SiPrefixParseErrorZ { match lightning_invoice::SiPrefix::from_str(s.into_str()) { Ok(r) => { crate::c_types::CResultTempl::ok( crate::lightning_invoice::SiPrefix::native_into(r) ) }, - Err(e) => crate::c_types::CResultTempl::err(()), + Err(e) => { + crate::c_types::CResultTempl::err( + crate::lightning_invoice::ParseError::native_into(e) + ) + }, }.into() } #[no_mangle] /// Read a Invoice object from a string -pub extern "C" fn Invoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_InvoiceNoneZ { +pub extern "C" fn Invoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_InvoiceParseOrSemanticErrorZ { match lightning_invoice::Invoice::from_str(s.into_str()) { Ok(r) => { crate::c_types::CResultTempl::ok( crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(r), is_owned: true } ) }, - Err(e) => crate::c_types::CResultTempl::err(()), + Err(e) => { + crate::c_types::CResultTempl::err( + crate::lightning_invoice::ParseOrSemanticError::native_into(e) + ) + }, }.into() } #[no_mangle] /// Read a SignedRawInvoice object from a string -pub extern "C" fn SignedRawInvoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SignedRawInvoiceNoneZ { +pub extern "C" fn SignedRawInvoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SignedRawInvoiceParseErrorZ { match lightning_invoice::SignedRawInvoice::from_str(s.into_str()) { Ok(r) => { crate::c_types::CResultTempl::ok( crate::lightning_invoice::SignedRawInvoice { inner: ObjOps::heap_alloc(r), is_owned: true } ) }, - Err(e) => crate::c_types::CResultTempl::err(()), + Err(e) => { + crate::c_types::CResultTempl::err( + crate::lightning_invoice::ParseError::native_into(e) + ) + }, }.into() } +#[no_mangle] +/// Get the string representation of a ParseError object +pub extern "C" fn ParseError_to_str(o: &crate::lightning_invoice::ParseError) -> Str { + alloc::format!("{}", &o.to_native()).into() +} +#[no_mangle] +/// Get the string representation of a ParseOrSemanticError object +pub extern "C" fn ParseOrSemanticError_to_str(o: &crate::lightning_invoice::ParseOrSemanticError) -> Str { + alloc::format!("{}", &o.to_native()).into() +} } mod ser { @@ -147,6 +182,423 @@ use crate::c_types::*; #[cfg(feature="no-std")] use alloc::{vec::Vec, boxed::Box}; +} +/// Errors that indicate what is wrong with the invoice. They have some granularity for debug +/// reasons, but should generally result in an \"invalid BOLT11 invoice\" message for the user. +#[derive(Clone)] +#[must_use] +#[repr(C)] +pub enum ParseError { + Bech32Error( + crate::c_types::Bech32Error), + ParseAmountError( + crate::c_types::Error), + MalformedSignature( + crate::c_types::Secp256k1Error), + BadPrefix, + UnknownCurrency, + UnknownSiPrefix, + MalformedHRP, + TooShortDataPart, + UnexpectedEndOfTaggedFields, + DescriptionDecodeError( + crate::c_types::Error), + PaddingError, + IntegerOverflowError, + InvalidSegWitProgramLength, + InvalidPubKeyHashLength, + InvalidScriptHashLength, + InvalidRecoveryId, + InvalidSliceLength( + crate::c_types::Str), + /// Not an error, but used internally to signal that a part of the invoice should be ignored + /// according to BOLT11 + Skip, +} +use lightning_invoice::ParseError as ParseErrorImport; +pub(crate) type nativeParseError = ParseErrorImport; + +impl ParseError { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeParseError { + match self { + ParseError::Bech32Error (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseError::Bech32Error ( + a_nonref.into_rust(), + ) + }, + ParseError::ParseAmountError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseError::ParseAmountError ( + u8::from_str_radix(" a", 10).unwrap_err() /*a_nonref*/, + ) + }, + ParseError::MalformedSignature (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseError::MalformedSignature ( + a_nonref.into_rust(), + ) + }, + ParseError::BadPrefix => nativeParseError::BadPrefix, + ParseError::UnknownCurrency => nativeParseError::UnknownCurrency, + ParseError::UnknownSiPrefix => nativeParseError::UnknownSiPrefix, + ParseError::MalformedHRP => nativeParseError::MalformedHRP, + ParseError::TooShortDataPart => nativeParseError::TooShortDataPart, + ParseError::UnexpectedEndOfTaggedFields => nativeParseError::UnexpectedEndOfTaggedFields, + ParseError::DescriptionDecodeError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseError::DescriptionDecodeError ( + core::str::from_utf8(&[0xff]).unwrap_err() /*a_nonref*/, + ) + }, + ParseError::PaddingError => nativeParseError::PaddingError, + ParseError::IntegerOverflowError => nativeParseError::IntegerOverflowError, + ParseError::InvalidSegWitProgramLength => nativeParseError::InvalidSegWitProgramLength, + ParseError::InvalidPubKeyHashLength => nativeParseError::InvalidPubKeyHashLength, + ParseError::InvalidScriptHashLength => nativeParseError::InvalidScriptHashLength, + ParseError::InvalidRecoveryId => nativeParseError::InvalidRecoveryId, + ParseError::InvalidSliceLength (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseError::InvalidSliceLength ( + a_nonref.into_string(), + ) + }, + ParseError::Skip => nativeParseError::Skip, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeParseError { + match self { + ParseError::Bech32Error (mut a, ) => { + nativeParseError::Bech32Error ( + a.into_rust(), + ) + }, + ParseError::ParseAmountError (mut a, ) => { + nativeParseError::ParseAmountError ( + u8::from_str_radix(" a", 10).unwrap_err() /*a*/, + ) + }, + ParseError::MalformedSignature (mut a, ) => { + nativeParseError::MalformedSignature ( + a.into_rust(), + ) + }, + ParseError::BadPrefix => nativeParseError::BadPrefix, + ParseError::UnknownCurrency => nativeParseError::UnknownCurrency, + ParseError::UnknownSiPrefix => nativeParseError::UnknownSiPrefix, + ParseError::MalformedHRP => nativeParseError::MalformedHRP, + ParseError::TooShortDataPart => nativeParseError::TooShortDataPart, + ParseError::UnexpectedEndOfTaggedFields => nativeParseError::UnexpectedEndOfTaggedFields, + ParseError::DescriptionDecodeError (mut a, ) => { + nativeParseError::DescriptionDecodeError ( + core::str::from_utf8(&[0xff]).unwrap_err() /*a*/, + ) + }, + ParseError::PaddingError => nativeParseError::PaddingError, + ParseError::IntegerOverflowError => nativeParseError::IntegerOverflowError, + ParseError::InvalidSegWitProgramLength => nativeParseError::InvalidSegWitProgramLength, + ParseError::InvalidPubKeyHashLength => nativeParseError::InvalidPubKeyHashLength, + ParseError::InvalidScriptHashLength => nativeParseError::InvalidScriptHashLength, + ParseError::InvalidRecoveryId => nativeParseError::InvalidRecoveryId, + ParseError::InvalidSliceLength (mut a, ) => { + nativeParseError::InvalidSliceLength ( + a.into_string(), + ) + }, + ParseError::Skip => nativeParseError::Skip, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeParseError) -> Self { + match native { + nativeParseError::Bech32Error (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseError::Bech32Error ( + crate::c_types::Bech32Error::from_rust(a_nonref), + ) + }, + nativeParseError::ParseAmountError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseError::ParseAmountError ( + crate::c_types::Error { _dummy: 0 } /*a_nonref*/, + ) + }, + nativeParseError::MalformedSignature (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseError::MalformedSignature ( + crate::c_types::Secp256k1Error::from_rust(a_nonref), + ) + }, + nativeParseError::BadPrefix => ParseError::BadPrefix, + nativeParseError::UnknownCurrency => ParseError::UnknownCurrency, + nativeParseError::UnknownSiPrefix => ParseError::UnknownSiPrefix, + nativeParseError::MalformedHRP => ParseError::MalformedHRP, + nativeParseError::TooShortDataPart => ParseError::TooShortDataPart, + nativeParseError::UnexpectedEndOfTaggedFields => ParseError::UnexpectedEndOfTaggedFields, + nativeParseError::DescriptionDecodeError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseError::DescriptionDecodeError ( + crate::c_types::Error { _dummy: 0 } /*a_nonref*/, + ) + }, + nativeParseError::PaddingError => ParseError::PaddingError, + nativeParseError::IntegerOverflowError => ParseError::IntegerOverflowError, + nativeParseError::InvalidSegWitProgramLength => ParseError::InvalidSegWitProgramLength, + nativeParseError::InvalidPubKeyHashLength => ParseError::InvalidPubKeyHashLength, + nativeParseError::InvalidScriptHashLength => ParseError::InvalidScriptHashLength, + nativeParseError::InvalidRecoveryId => ParseError::InvalidRecoveryId, + nativeParseError::InvalidSliceLength (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseError::InvalidSliceLength ( + a_nonref.into(), + ) + }, + nativeParseError::Skip => ParseError::Skip, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeParseError) -> Self { + match native { + nativeParseError::Bech32Error (mut a, ) => { + ParseError::Bech32Error ( + crate::c_types::Bech32Error::from_rust(a), + ) + }, + nativeParseError::ParseAmountError (mut a, ) => { + ParseError::ParseAmountError ( + crate::c_types::Error { _dummy: 0 } /*a*/, + ) + }, + nativeParseError::MalformedSignature (mut a, ) => { + ParseError::MalformedSignature ( + crate::c_types::Secp256k1Error::from_rust(a), + ) + }, + nativeParseError::BadPrefix => ParseError::BadPrefix, + nativeParseError::UnknownCurrency => ParseError::UnknownCurrency, + nativeParseError::UnknownSiPrefix => ParseError::UnknownSiPrefix, + nativeParseError::MalformedHRP => ParseError::MalformedHRP, + nativeParseError::TooShortDataPart => ParseError::TooShortDataPart, + nativeParseError::UnexpectedEndOfTaggedFields => ParseError::UnexpectedEndOfTaggedFields, + nativeParseError::DescriptionDecodeError (mut a, ) => { + ParseError::DescriptionDecodeError ( + crate::c_types::Error { _dummy: 0 } /*a*/, + ) + }, + nativeParseError::PaddingError => ParseError::PaddingError, + nativeParseError::IntegerOverflowError => ParseError::IntegerOverflowError, + nativeParseError::InvalidSegWitProgramLength => ParseError::InvalidSegWitProgramLength, + nativeParseError::InvalidPubKeyHashLength => ParseError::InvalidPubKeyHashLength, + nativeParseError::InvalidScriptHashLength => ParseError::InvalidScriptHashLength, + nativeParseError::InvalidRecoveryId => ParseError::InvalidRecoveryId, + nativeParseError::InvalidSliceLength (mut a, ) => { + ParseError::InvalidSliceLength ( + a.into(), + ) + }, + nativeParseError::Skip => ParseError::Skip, + } + } +} +/// Frees any resources used by the ParseError +#[no_mangle] +pub extern "C" fn ParseError_free(this_ptr: ParseError) { } +/// Creates a copy of the ParseError +#[no_mangle] +pub extern "C" fn ParseError_clone(orig: &ParseError) -> ParseError { + orig.clone() +} +#[no_mangle] +/// Utility method to constructs a new Bech32Error-variant ParseError +pub extern "C" fn ParseError_bech32_error(a: crate::c_types::Bech32Error) -> ParseError { + ParseError::Bech32Error(a, ) +} +#[no_mangle] +/// Utility method to constructs a new ParseAmountError-variant ParseError +pub extern "C" fn ParseError_parse_amount_error(a: crate::c_types::Error) -> ParseError { + ParseError::ParseAmountError(a, ) +} +#[no_mangle] +/// Utility method to constructs a new MalformedSignature-variant ParseError +pub extern "C" fn ParseError_malformed_signature(a: crate::c_types::Secp256k1Error) -> ParseError { + ParseError::MalformedSignature(a, ) +} +#[no_mangle] +/// Utility method to constructs a new BadPrefix-variant ParseError +pub extern "C" fn ParseError_bad_prefix() -> ParseError { + ParseError::BadPrefix} +#[no_mangle] +/// Utility method to constructs a new UnknownCurrency-variant ParseError +pub extern "C" fn ParseError_unknown_currency() -> ParseError { + ParseError::UnknownCurrency} +#[no_mangle] +/// Utility method to constructs a new UnknownSiPrefix-variant ParseError +pub extern "C" fn ParseError_unknown_si_prefix() -> ParseError { + ParseError::UnknownSiPrefix} +#[no_mangle] +/// Utility method to constructs a new MalformedHRP-variant ParseError +pub extern "C" fn ParseError_malformed_hrp() -> ParseError { + ParseError::MalformedHRP} +#[no_mangle] +/// Utility method to constructs a new TooShortDataPart-variant ParseError +pub extern "C" fn ParseError_too_short_data_part() -> ParseError { + ParseError::TooShortDataPart} +#[no_mangle] +/// Utility method to constructs a new UnexpectedEndOfTaggedFields-variant ParseError +pub extern "C" fn ParseError_unexpected_end_of_tagged_fields() -> ParseError { + ParseError::UnexpectedEndOfTaggedFields} +#[no_mangle] +/// Utility method to constructs a new DescriptionDecodeError-variant ParseError +pub extern "C" fn ParseError_description_decode_error(a: crate::c_types::Error) -> ParseError { + ParseError::DescriptionDecodeError(a, ) +} +#[no_mangle] +/// Utility method to constructs a new PaddingError-variant ParseError +pub extern "C" fn ParseError_padding_error() -> ParseError { + ParseError::PaddingError} +#[no_mangle] +/// Utility method to constructs a new IntegerOverflowError-variant ParseError +pub extern "C" fn ParseError_integer_overflow_error() -> ParseError { + ParseError::IntegerOverflowError} +#[no_mangle] +/// Utility method to constructs a new InvalidSegWitProgramLength-variant ParseError +pub extern "C" fn ParseError_invalid_seg_wit_program_length() -> ParseError { + ParseError::InvalidSegWitProgramLength} +#[no_mangle] +/// Utility method to constructs a new InvalidPubKeyHashLength-variant ParseError +pub extern "C" fn ParseError_invalid_pub_key_hash_length() -> ParseError { + ParseError::InvalidPubKeyHashLength} +#[no_mangle] +/// Utility method to constructs a new InvalidScriptHashLength-variant ParseError +pub extern "C" fn ParseError_invalid_script_hash_length() -> ParseError { + ParseError::InvalidScriptHashLength} +#[no_mangle] +/// Utility method to constructs a new InvalidRecoveryId-variant ParseError +pub extern "C" fn ParseError_invalid_recovery_id() -> ParseError { + ParseError::InvalidRecoveryId} +#[no_mangle] +/// Utility method to constructs a new InvalidSliceLength-variant ParseError +pub extern "C" fn ParseError_invalid_slice_length(a: crate::c_types::Str) -> ParseError { + ParseError::InvalidSliceLength(a, ) +} +#[no_mangle] +/// Utility method to constructs a new Skip-variant ParseError +pub extern "C" fn ParseError_skip() -> ParseError { + ParseError::Skip} +/// Checks if two ParseErrors contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn ParseError_eq(a: &ParseError, b: &ParseError) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } +} +/// Indicates that something went wrong while parsing or validating the invoice. Parsing errors +/// should be mostly seen as opaque and are only there for debugging reasons. Semantic errors +/// like wrong signatures, missing fields etc. could mean that someone tampered with the invoice. +#[derive(Clone)] +#[must_use] +#[repr(C)] +pub enum ParseOrSemanticError { + /// The invoice couldn't be decoded + ParseError( + crate::lightning_invoice::ParseError), + /// The invoice could be decoded but violates the BOLT11 standard + SemanticError( + crate::lightning_invoice::SemanticError), +} +use lightning_invoice::ParseOrSemanticError as ParseOrSemanticErrorImport; +pub(crate) type nativeParseOrSemanticError = ParseOrSemanticErrorImport; + +impl ParseOrSemanticError { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeParseOrSemanticError { + match self { + ParseOrSemanticError::ParseError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseOrSemanticError::ParseError ( + a_nonref.into_native(), + ) + }, + ParseOrSemanticError::SemanticError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeParseOrSemanticError::SemanticError ( + a_nonref.into_native(), + ) + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeParseOrSemanticError { + match self { + ParseOrSemanticError::ParseError (mut a, ) => { + nativeParseOrSemanticError::ParseError ( + a.into_native(), + ) + }, + ParseOrSemanticError::SemanticError (mut a, ) => { + nativeParseOrSemanticError::SemanticError ( + a.into_native(), + ) + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeParseOrSemanticError) -> Self { + match native { + nativeParseOrSemanticError::ParseError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseOrSemanticError::ParseError ( + crate::lightning_invoice::ParseError::native_into(a_nonref), + ) + }, + nativeParseOrSemanticError::SemanticError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + ParseOrSemanticError::SemanticError ( + crate::lightning_invoice::SemanticError::native_into(a_nonref), + ) + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeParseOrSemanticError) -> Self { + match native { + nativeParseOrSemanticError::ParseError (mut a, ) => { + ParseOrSemanticError::ParseError ( + crate::lightning_invoice::ParseError::native_into(a), + ) + }, + nativeParseOrSemanticError::SemanticError (mut a, ) => { + ParseOrSemanticError::SemanticError ( + crate::lightning_invoice::SemanticError::native_into(a), + ) + }, + } + } +} +/// Frees any resources used by the ParseOrSemanticError +#[no_mangle] +pub extern "C" fn ParseOrSemanticError_free(this_ptr: ParseOrSemanticError) { } +/// Creates a copy of the ParseOrSemanticError +#[no_mangle] +pub extern "C" fn ParseOrSemanticError_clone(orig: &ParseOrSemanticError) -> ParseOrSemanticError { + orig.clone() +} +#[no_mangle] +/// Utility method to constructs a new ParseError-variant ParseOrSemanticError +pub extern "C" fn ParseOrSemanticError_parse_error(a: crate::lightning_invoice::ParseError) -> ParseOrSemanticError { + ParseOrSemanticError::ParseError(a, ) +} +#[no_mangle] +/// Utility method to constructs a new SemanticError-variant ParseOrSemanticError +pub extern "C" fn ParseOrSemanticError_semantic_error(a: crate::lightning_invoice::SemanticError) -> ParseOrSemanticError { + ParseOrSemanticError::SemanticError(a, ) +} +/// Checks if two ParseOrSemanticErrors contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn ParseOrSemanticError_eq(a: &ParseOrSemanticError, b: &ParseOrSemanticError) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } } /// The maximum timestamp as [`Duration::as_secs`] since the Unix epoch allowed by [`BOLT 11`]. /// @@ -163,13 +615,13 @@ pub static DEFAULT_EXPIRY_TIME: u64 = lightning_invoice::DEFAULT_EXPIRY_TIME; /// Default minimum final CLTV expiry as defined by [BOLT 11]. /// /// Note that this is *not* the same value as rust-lightning's minimum CLTV expiry, which is -/// provided in [`MIN_FINAL_CLTV_EXPIRY`]. +/// provided in [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. /// /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md -/// [`MIN_FINAL_CLTV_EXPIRY`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY +/// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA #[no_mangle] -pub static DEFAULT_MIN_FINAL_CLTV_EXPIRY: u64 = lightning_invoice::DEFAULT_MIN_FINAL_CLTV_EXPIRY; +pub static DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA: u64 = lightning_invoice::DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA; use lightning_invoice::Invoice as nativeInvoiceImport; pub(crate) type nativeInvoice = nativeInvoiceImport; @@ -177,9 +629,11 @@ pub(crate) type nativeInvoice = nativeInvoiceImport; /// Represents a syntactically and semantically correct lightning BOLT11 invoice. /// /// There are three ways to construct an `Invoice`: -/// 1. using `InvoiceBuilder` -/// 2. using `Invoice::from_signed(SignedRawInvoice)` -/// 3. using `str::parse::(&str)` +/// 1. using [`InvoiceBuilder`] +/// 2. using [`Invoice::from_signed`] +/// 3. using `str::parse::(&str)` (see [`Invoice::from_str`]) +/// +/// [`Invoice::from_str`]: crate::Invoice#impl-FromStr #[must_use] #[repr(C)] pub struct Invoice { @@ -208,7 +662,7 @@ pub extern "C" fn Invoice_free(this_obj: Invoice) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn Invoice_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInvoice); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeInvoice) }; } #[allow(unused)] impl Invoice { @@ -254,15 +708,25 @@ pub(crate) extern "C" fn Invoice_clone_void(this_ptr: *const c_void) -> *mut c_v pub extern "C" fn Invoice_clone(orig: &Invoice) -> Invoice { orig.clone() } +/// Generates a non-cryptographic 64-bit hash of the Invoice. +#[no_mangle] +pub extern "C" fn Invoice_hash(o: &Invoice) -> 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) +} use lightning_invoice::SignedRawInvoice as nativeSignedRawInvoiceImport; pub(crate) type nativeSignedRawInvoice = nativeSignedRawInvoiceImport; -/// Represents a signed `RawInvoice` with cached hash. The signature is not checked and may be +/// Represents a signed [`RawInvoice`] with cached hash. The signature is not checked and may be /// invalid. /// /// # Invariants -/// The hash has to be either from the deserialized invoice or from the serialized `raw_invoice`. +/// The hash has to be either from the deserialized invoice or from the serialized [`RawInvoice`]. #[must_use] #[repr(C)] pub struct SignedRawInvoice { @@ -291,7 +755,7 @@ pub extern "C" fn SignedRawInvoice_free(this_obj: SignedRawInvoice) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn SignedRawInvoice_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeSignedRawInvoice); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSignedRawInvoice) }; } #[allow(unused)] impl SignedRawInvoice { @@ -337,15 +801,25 @@ pub(crate) extern "C" fn SignedRawInvoice_clone_void(this_ptr: *const c_void) -> pub extern "C" fn SignedRawInvoice_clone(orig: &SignedRawInvoice) -> SignedRawInvoice { orig.clone() } +/// Generates a non-cryptographic 64-bit hash of the SignedRawInvoice. +#[no_mangle] +pub extern "C" fn SignedRawInvoice_hash(o: &SignedRawInvoice) -> 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) +} use lightning_invoice::RawInvoice as nativeRawInvoiceImport; pub(crate) type nativeRawInvoice = nativeRawInvoiceImport; -/// Represents an syntactically correct Invoice for a payment on the lightning network, +/// Represents an syntactically correct [`Invoice`] for a payment on the lightning network, /// but without the signature information. -/// De- and encoding should not lead to information loss but may lead to different hashes. +/// Decoding and encoding should not lead to information loss but may lead to different hashes. /// -/// For methods without docs see the corresponding methods in `Invoice`. +/// For methods without docs see the corresponding methods in [`Invoice`]. #[must_use] #[repr(C)] pub struct RawInvoice { @@ -374,7 +848,7 @@ pub extern "C" fn RawInvoice_free(this_obj: RawInvoice) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn RawInvoice_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRawInvoice); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRawInvoice) }; } #[allow(unused)] impl RawInvoice { @@ -431,11 +905,21 @@ pub(crate) extern "C" fn RawInvoice_clone_void(this_ptr: *const c_void) -> *mut pub extern "C" fn RawInvoice_clone(orig: &RawInvoice) -> RawInvoice { orig.clone() } +/// Generates a non-cryptographic 64-bit hash of the RawInvoice. +#[no_mangle] +pub extern "C" fn RawInvoice_hash(o: &RawInvoice) -> 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) +} use lightning_invoice::RawDataPart as nativeRawDataPartImport; pub(crate) type nativeRawDataPart = nativeRawDataPartImport; -/// Data of the `RawInvoice` that is encoded in the data part +/// Data of the [`RawInvoice`] that is encoded in the data part #[must_use] #[repr(C)] pub struct RawDataPart { @@ -464,7 +948,7 @@ pub extern "C" fn RawDataPart_free(this_obj: RawDataPart) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn RawDataPart_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRawDataPart); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRawDataPart) }; } #[allow(unused)] impl RawDataPart { @@ -521,6 +1005,16 @@ pub(crate) extern "C" fn RawDataPart_clone_void(this_ptr: *const c_void) -> *mut pub extern "C" fn RawDataPart_clone(orig: &RawDataPart) -> RawDataPart { orig.clone() } +/// Generates a non-cryptographic 64-bit hash of the RawDataPart. +#[no_mangle] +pub extern "C" fn RawDataPart_hash(o: &RawDataPart) -> 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) +} use lightning_invoice::PositiveTimestamp as nativePositiveTimestampImport; pub(crate) type nativePositiveTimestamp = nativePositiveTimestampImport; @@ -559,7 +1053,7 @@ pub extern "C" fn PositiveTimestamp_free(this_obj: PositiveTimestamp) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn PositiveTimestamp_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativePositiveTimestamp); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativePositiveTimestamp) }; } #[allow(unused)] impl PositiveTimestamp { @@ -605,9 +1099,19 @@ pub(crate) extern "C" fn PositiveTimestamp_clone_void(this_ptr: *const c_void) - pub extern "C" fn PositiveTimestamp_clone(orig: &PositiveTimestamp) -> PositiveTimestamp { orig.clone() } +/// Generates a non-cryptographic 64-bit hash of the PositiveTimestamp. +#[no_mangle] +pub extern "C" fn PositiveTimestamp_hash(o: &PositiveTimestamp) -> 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) +} /// SI prefixes for the human readable part -#[must_use] #[derive(Clone)] +#[must_use] #[repr(C)] pub enum SiPrefix { /// 10^-3 @@ -619,7 +1123,9 @@ pub enum SiPrefix { /// 10^-12 Pico, } -use lightning_invoice::SiPrefix as nativeSiPrefix; +use lightning_invoice::SiPrefix as SiPrefixImport; +pub(crate) type nativeSiPrefix = SiPrefixImport; + impl SiPrefix { #[allow(unused)] pub(crate) fn to_native(&self) -> nativeSiPrefix { @@ -685,18 +1191,27 @@ pub extern "C" fn SiPrefix_pico() -> SiPrefix { pub extern "C" fn SiPrefix_eq(a: &SiPrefix, b: &SiPrefix) -> bool { if &a.to_native() == &b.to_native() { true } else { false } } +/// Generates a non-cryptographic 64-bit hash of the SiPrefix. +#[no_mangle] +pub extern "C" fn SiPrefix_hash(o: &SiPrefix) -> 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) +} /// Returns the multiplier to go from a BTC value to picoBTC implied by this SiPrefix. /// This is effectively 10^12 * the prefix multiplier #[must_use] #[no_mangle] -pub extern "C" fn SiPrefix_multiplier(this_arg: &SiPrefix) -> u64 { +pub extern "C" fn SiPrefix_multiplier(this_arg: &crate::lightning_invoice::SiPrefix) -> u64 { let mut ret = this_arg.to_native().multiplier(); ret } /// Enum representing the crypto currencies (or networks) supported by this library -#[must_use] #[derive(Clone)] +#[must_use] #[repr(C)] pub enum Currency { /// Bitcoin mainnet @@ -710,7 +1225,9 @@ pub enum Currency { /// Bitcoin signet Signet, } -use lightning_invoice::Currency as nativeCurrency; +use lightning_invoice::Currency as CurrencyImport; +pub(crate) type nativeCurrency = CurrencyImport; + impl Currency { #[allow(unused)] pub(crate) fn to_native(&self) -> nativeCurrency { @@ -778,7 +1295,7 @@ pub extern "C" fn Currency_simnet() -> Currency { /// Utility method to constructs a new Signet-variant Currency pub extern "C" fn Currency_signet() -> Currency { Currency::Signet} -/// Checks if two Currencys contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the Currency. #[no_mangle] pub extern "C" fn Currency_hash(o: &Currency) -> u64 { // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core @@ -826,7 +1343,7 @@ pub extern "C" fn Sha256_free(this_obj: Sha256) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn Sha256_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeSha256); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSha256) }; } #[allow(unused)] impl Sha256 { @@ -863,7 +1380,7 @@ pub(crate) extern "C" fn Sha256_clone_void(this_ptr: *const c_void) -> *mut c_vo pub extern "C" fn Sha256_clone(orig: &Sha256) -> Sha256 { orig.clone() } -/// Checks if two Sha256s contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the Sha256. #[no_mangle] pub extern "C" fn Sha256_hash(o: &Sha256) -> u64 { if o.inner.is_null() { return 0; } @@ -882,6 +1399,15 @@ pub extern "C" fn Sha256_eq(a: &Sha256, b: &Sha256) -> bool { if a.inner.is_null() || b.inner.is_null() { return false; } if a.get_native_ref() == b.get_native_ref() { true } else { false } } +/// Constructs a new [`Sha256`] from the given bytes, which are assumed to be the output of a +/// single sha256 hash. +#[must_use] +#[no_mangle] +pub extern "C" fn Sha256_from_bytes(bytes: *const [u8; 32]) -> crate::lightning_invoice::Sha256 { + let mut ret = lightning_invoice::Sha256::from_bytes(unsafe { &*bytes}); + crate::lightning_invoice::Sha256 { inner: ObjOps::heap_alloc(ret), is_owned: true } +} + use lightning_invoice::Description as nativeDescriptionImport; pub(crate) type nativeDescription = nativeDescriptionImport; @@ -918,7 +1444,7 @@ pub extern "C" fn Description_free(this_obj: Description) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn Description_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDescription); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeDescription) }; } #[allow(unused)] impl Description { @@ -955,7 +1481,7 @@ pub(crate) extern "C" fn Description_clone_void(this_ptr: *const c_void) -> *mut pub extern "C" fn Description_clone(orig: &Description) -> Description { orig.clone() } -/// Checks if two Descriptions contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the Description. #[no_mangle] pub extern "C" fn Description_hash(o: &Description) -> u64 { if o.inner.is_null() { return 0; } @@ -1007,7 +1533,7 @@ pub extern "C" fn PayeePubKey_free(this_obj: PayeePubKey) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn PayeePubKey_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativePayeePubKey); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativePayeePubKey) }; } #[allow(unused)] impl PayeePubKey { @@ -1061,7 +1587,7 @@ pub(crate) extern "C" fn PayeePubKey_clone_void(this_ptr: *const c_void) -> *mut pub extern "C" fn PayeePubKey_clone(orig: &PayeePubKey) -> PayeePubKey { orig.clone() } -/// Checks if two PayeePubKeys contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the PayeePubKey. #[no_mangle] pub extern "C" fn PayeePubKey_hash(o: &PayeePubKey) -> u64 { if o.inner.is_null() { return 0; } @@ -1114,7 +1640,7 @@ pub extern "C" fn ExpiryTime_free(this_obj: ExpiryTime) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn ExpiryTime_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeExpiryTime); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeExpiryTime) }; } #[allow(unused)] impl ExpiryTime { @@ -1151,7 +1677,7 @@ pub(crate) extern "C" fn ExpiryTime_clone_void(this_ptr: *const c_void) -> *mut pub extern "C" fn ExpiryTime_clone(orig: &ExpiryTime) -> ExpiryTime { orig.clone() } -/// Checks if two ExpiryTimes contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the ExpiryTime. #[no_mangle] pub extern "C" fn ExpiryTime_hash(o: &ExpiryTime) -> u64 { if o.inner.is_null() { return 0; } @@ -1171,18 +1697,18 @@ pub extern "C" fn ExpiryTime_eq(a: &ExpiryTime, b: &ExpiryTime) -> bool { if a.get_native_ref() == b.get_native_ref() { true } else { false } } -use lightning_invoice::MinFinalCltvExpiry as nativeMinFinalCltvExpiryImport; -pub(crate) type nativeMinFinalCltvExpiry = nativeMinFinalCltvExpiryImport; +use lightning_invoice::MinFinalCltvExpiryDelta as nativeMinFinalCltvExpiryDeltaImport; +pub(crate) type nativeMinFinalCltvExpiryDelta = nativeMinFinalCltvExpiryDeltaImport; -/// `min_final_cltv_expiry` to use for the last HTLC in the route +/// `min_final_cltv_expiry_delta` to use for the last HTLC in the route #[must_use] #[repr(C)] -pub struct MinFinalCltvExpiry { +pub struct MinFinalCltvExpiryDelta { /// 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 nativeMinFinalCltvExpiry, + pub inner: *mut nativeMinFinalCltvExpiryDelta, /// 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 @@ -1190,31 +1716,31 @@ pub struct MinFinalCltvExpiry { pub is_owned: bool, } -impl Drop for MinFinalCltvExpiry { +impl Drop for MinFinalCltvExpiryDelta { fn drop(&mut self) { - if self.is_owned && !<*mut nativeMinFinalCltvExpiry>::is_null(self.inner) { + if self.is_owned && !<*mut nativeMinFinalCltvExpiryDelta>::is_null(self.inner) { let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; } } } -/// Frees any resources used by the MinFinalCltvExpiry, if is_owned is set and inner is non-NULL. +/// Frees any resources used by the MinFinalCltvExpiryDelta, if is_owned is set and inner is non-NULL. #[no_mangle] -pub extern "C" fn MinFinalCltvExpiry_free(this_obj: MinFinalCltvExpiry) { } +pub extern "C" fn MinFinalCltvExpiryDelta_free(this_obj: MinFinalCltvExpiryDelta) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method -pub(crate) extern "C" fn MinFinalCltvExpiry_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeMinFinalCltvExpiry); } +pub(crate) extern "C" fn MinFinalCltvExpiryDelta_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeMinFinalCltvExpiryDelta) }; } #[allow(unused)] -impl MinFinalCltvExpiry { - pub(crate) fn get_native_ref(&self) -> &'static nativeMinFinalCltvExpiry { +impl MinFinalCltvExpiryDelta { + pub(crate) fn get_native_ref(&self) -> &'static nativeMinFinalCltvExpiryDelta { unsafe { &*ObjOps::untweak_ptr(self.inner) } } - pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeMinFinalCltvExpiry { + pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeMinFinalCltvExpiryDelta { 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 nativeMinFinalCltvExpiry { + pub(crate) fn take_inner(mut self) -> *mut nativeMinFinalCltvExpiryDelta { assert!(self.is_owned); let ret = ObjOps::untweak_ptr(self.inner); self.inner = core::ptr::null_mut(); @@ -1222,26 +1748,26 @@ impl MinFinalCltvExpiry { } } #[no_mangle] -pub extern "C" fn MinFinalCltvExpiry_get_a(this_ptr: &MinFinalCltvExpiry) -> u64 { +pub extern "C" fn MinFinalCltvExpiryDelta_get_a(this_ptr: &MinFinalCltvExpiryDelta) -> u64 { let mut inner_val = &mut this_ptr.get_native_mut_ref().0; *inner_val } #[no_mangle] -pub extern "C" fn MinFinalCltvExpiry_set_a(this_ptr: &mut MinFinalCltvExpiry, mut val: u64) { +pub extern "C" fn MinFinalCltvExpiryDelta_set_a(this_ptr: &mut MinFinalCltvExpiryDelta, mut val: u64) { unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.0 = val; } -/// Constructs a new MinFinalCltvExpiry given each field +/// Constructs a new MinFinalCltvExpiryDelta given each field #[must_use] #[no_mangle] -pub extern "C" fn MinFinalCltvExpiry_new(mut a_arg: u64) -> MinFinalCltvExpiry { - MinFinalCltvExpiry { inner: ObjOps::heap_alloc(lightning_invoice::MinFinalCltvExpiry ( +pub extern "C" fn MinFinalCltvExpiryDelta_new(mut a_arg: u64) -> MinFinalCltvExpiryDelta { + MinFinalCltvExpiryDelta { inner: ObjOps::heap_alloc(lightning_invoice::MinFinalCltvExpiryDelta ( a_arg, )), is_owned: true } } -impl Clone for MinFinalCltvExpiry { +impl Clone for MinFinalCltvExpiryDelta { fn clone(&self) -> Self { Self { - inner: if <*mut nativeMinFinalCltvExpiry>::is_null(self.inner) { core::ptr::null_mut() } else { + inner: if <*mut nativeMinFinalCltvExpiryDelta>::is_null(self.inner) { core::ptr::null_mut() } else { ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) }, is_owned: true, } @@ -1249,17 +1775,17 @@ impl Clone for MinFinalCltvExpiry { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method -pub(crate) extern "C" fn MinFinalCltvExpiry_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeMinFinalCltvExpiry)).clone() })) as *mut c_void +pub(crate) extern "C" fn MinFinalCltvExpiryDelta_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeMinFinalCltvExpiryDelta)).clone() })) as *mut c_void } #[no_mangle] -/// Creates a copy of the MinFinalCltvExpiry -pub extern "C" fn MinFinalCltvExpiry_clone(orig: &MinFinalCltvExpiry) -> MinFinalCltvExpiry { +/// Creates a copy of the MinFinalCltvExpiryDelta +pub extern "C" fn MinFinalCltvExpiryDelta_clone(orig: &MinFinalCltvExpiryDelta) -> MinFinalCltvExpiryDelta { orig.clone() } -/// Checks if two MinFinalCltvExpirys contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the MinFinalCltvExpiryDelta. #[no_mangle] -pub extern "C" fn MinFinalCltvExpiry_hash(o: &MinFinalCltvExpiry) -> u64 { +pub extern "C" fn MinFinalCltvExpiryDelta_hash(o: &MinFinalCltvExpiryDelta) -> 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)] @@ -1267,35 +1793,39 @@ pub extern "C" fn MinFinalCltvExpiry_hash(o: &MinFinalCltvExpiry) -> u64 { core::hash::Hash::hash(o.get_native_ref(), &mut hasher); core::hash::Hasher::finish(&hasher) } -/// Checks if two MinFinalCltvExpirys contain equal inner contents. +/// Checks if two MinFinalCltvExpiryDeltas 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 MinFinalCltvExpiry_eq(a: &MinFinalCltvExpiry, b: &MinFinalCltvExpiry) -> bool { +pub extern "C" fn MinFinalCltvExpiryDelta_eq(a: &MinFinalCltvExpiryDelta, b: &MinFinalCltvExpiryDelta) -> 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 } } /// Fallback address in case no LN payment is possible -#[must_use] #[derive(Clone)] +#[must_use] #[repr(C)] pub enum Fallback { SegWitProgram { - version: crate::c_types::u5, + version: crate::c_types::WitnessVersion, program: crate::c_types::derived::CVec_u8Z, }, - PubKeyHash(crate::c_types::TwentyBytes), - ScriptHash(crate::c_types::TwentyBytes), + PubKeyHash( + crate::c_types::TwentyBytes), + ScriptHash( + crate::c_types::TwentyBytes), } -use lightning_invoice::Fallback as nativeFallback; +use lightning_invoice::Fallback as FallbackImport; +pub(crate) type nativeFallback = FallbackImport; + impl Fallback { #[allow(unused)] pub(crate) fn to_native(&self) -> nativeFallback { match self { Fallback::SegWitProgram {ref version, ref program, } => { - let mut version_nonref = (*version).clone(); - let mut program_nonref = (*program).clone(); + let mut version_nonref = Clone::clone(version); + let mut program_nonref = Clone::clone(program); let mut local_program_nonref = Vec::new(); for mut item in program_nonref.into_rust().drain(..) { local_program_nonref.push( { item }); }; nativeFallback::SegWitProgram { version: version_nonref.into(), @@ -1303,15 +1833,15 @@ impl Fallback { } }, Fallback::PubKeyHash (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); nativeFallback::PubKeyHash ( - a_nonref.data, + bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(a_nonref.data)), ) }, Fallback::ScriptHash (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); nativeFallback::ScriptHash ( - a_nonref.data, + bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(a_nonref.data)), ) }, } @@ -1328,12 +1858,12 @@ impl Fallback { }, Fallback::PubKeyHash (mut a, ) => { nativeFallback::PubKeyHash ( - a.data, + bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(a.data)), ) }, Fallback::ScriptHash (mut a, ) => { nativeFallback::ScriptHash ( - a.data, + bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(a.data)), ) }, } @@ -1342,8 +1872,8 @@ impl Fallback { pub(crate) fn from_native(native: &nativeFallback) -> Self { match native { nativeFallback::SegWitProgram {ref version, ref program, } => { - let mut version_nonref = (*version).clone(); - let mut program_nonref = (*program).clone(); + let mut version_nonref = Clone::clone(version); + let mut program_nonref = Clone::clone(program); let mut local_program_nonref = Vec::new(); for mut item in program_nonref.drain(..) { local_program_nonref.push( { item }); }; Fallback::SegWitProgram { version: version_nonref.into(), @@ -1351,15 +1881,15 @@ impl Fallback { } }, nativeFallback::PubKeyHash (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); Fallback::PubKeyHash ( - crate::c_types::TwentyBytes { data: a_nonref }, + crate::c_types::TwentyBytes { data: a_nonref.as_hash().into_inner() }, ) }, nativeFallback::ScriptHash (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); Fallback::ScriptHash ( - crate::c_types::TwentyBytes { data: a_nonref }, + crate::c_types::TwentyBytes { data: a_nonref.as_hash().into_inner() }, ) }, } @@ -1376,12 +1906,12 @@ impl Fallback { }, nativeFallback::PubKeyHash (mut a, ) => { Fallback::PubKeyHash ( - crate::c_types::TwentyBytes { data: a }, + crate::c_types::TwentyBytes { data: a.as_hash().into_inner() }, ) }, nativeFallback::ScriptHash (mut a, ) => { Fallback::ScriptHash ( - crate::c_types::TwentyBytes { data: a }, + crate::c_types::TwentyBytes { data: a.as_hash().into_inner() }, ) }, } @@ -1397,7 +1927,7 @@ pub extern "C" fn Fallback_clone(orig: &Fallback) -> Fallback { } #[no_mangle] /// Utility method to constructs a new SegWitProgram-variant Fallback -pub extern "C" fn Fallback_seg_wit_program(version: crate::c_types::u5, program: crate::c_types::derived::CVec_u8Z) -> Fallback { +pub extern "C" fn Fallback_seg_wit_program(version: crate::c_types::WitnessVersion, program: crate::c_types::derived::CVec_u8Z) -> Fallback { Fallback::SegWitProgram { version, program, @@ -1413,7 +1943,7 @@ pub extern "C" fn Fallback_pub_key_hash(a: crate::c_types::TwentyBytes) -> Fallb pub extern "C" fn Fallback_script_hash(a: crate::c_types::TwentyBytes) -> Fallback { Fallback::ScriptHash(a, ) } -/// Checks if two Fallbacks contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the Fallback. #[no_mangle] pub extern "C" fn Fallback_hash(o: &Fallback) -> u64 { // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core @@ -1461,7 +1991,7 @@ pub extern "C" fn InvoiceSignature_free(this_obj: InvoiceSignature) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn InvoiceSignature_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInvoiceSignature); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeInvoiceSignature) }; } #[allow(unused)] impl InvoiceSignature { @@ -1498,6 +2028,16 @@ pub(crate) extern "C" fn InvoiceSignature_clone_void(this_ptr: *const c_void) -> pub extern "C" fn InvoiceSignature_clone(orig: &InvoiceSignature) -> InvoiceSignature { orig.clone() } +/// Generates a non-cryptographic 64-bit hash of the InvoiceSignature. +#[no_mangle] +pub extern "C" fn InvoiceSignature_hash(o: &InvoiceSignature) -> 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 InvoiceSignatures 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. @@ -1544,7 +2084,7 @@ pub extern "C" fn PrivateRoute_free(this_obj: PrivateRoute) { } #[allow(unused)] /// Used only if an object of this type is returned as a trait impl by a method pub(crate) extern "C" fn PrivateRoute_free_void(this_ptr: *mut c_void) { - unsafe { let _ = Box::from_raw(this_ptr as *mut nativePrivateRoute); } + let _ = unsafe { Box::from_raw(this_ptr as *mut nativePrivateRoute) }; } #[allow(unused)] impl PrivateRoute { @@ -1581,7 +2121,7 @@ pub(crate) extern "C" fn PrivateRoute_clone_void(this_ptr: *const c_void) -> *mu pub extern "C" fn PrivateRoute_clone(orig: &PrivateRoute) -> PrivateRoute { orig.clone() } -/// Checks if two PrivateRoutes contain equal inner contents. +/// Generates a non-cryptographic 64-bit hash of the PrivateRoute. #[no_mangle] pub extern "C" fn PrivateRoute_hash(o: &PrivateRoute) -> u64 { if o.inner.is_null() { return 0; } @@ -1606,32 +2146,32 @@ pub extern "C" fn PrivateRoute_eq(a: &PrivateRoute, b: &PrivateRoute) -> bool { /// 3. signature #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_into_parts(mut this_arg: SignedRawInvoice) -> crate::c_types::derived::C3Tuple_RawInvoice_u832InvoiceSignatureZ { +pub extern "C" fn SignedRawInvoice_into_parts(mut this_arg: crate::lightning_invoice::SignedRawInvoice) -> crate::c_types::derived::C3Tuple_RawInvoice_u832InvoiceSignatureZ { let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_parts(); let (mut orig_ret_0, mut orig_ret_1, mut orig_ret_2) = ret; let mut local_ret = (crate::lightning_invoice::RawInvoice { inner: ObjOps::heap_alloc(orig_ret_0), is_owned: true }, crate::c_types::ThirtyTwoBytes { data: orig_ret_1 }, crate::lightning_invoice::InvoiceSignature { inner: ObjOps::heap_alloc(orig_ret_2), is_owned: true }).into(); local_ret } -/// The `RawInvoice` which was signed. +/// The [`RawInvoice`] which was signed. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_raw_invoice(this_arg: &SignedRawInvoice) -> crate::lightning_invoice::RawInvoice { +pub extern "C" fn SignedRawInvoice_raw_invoice(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> crate::lightning_invoice::RawInvoice { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.raw_invoice(); crate::lightning_invoice::RawInvoice { inner: unsafe { ObjOps::nonnull_ptr_to_inner((ret as *const lightning_invoice::RawInvoice<>) as *mut _) }, is_owned: false } } -/// The hash of the `RawInvoice` that was signed. +/// The hash of the [`RawInvoice`] that was signed. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_hash(this_arg: &SignedRawInvoice) -> *const [u8; 32] { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.hash(); +pub extern "C" fn SignedRawInvoice_signable_hash(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> *const [u8; 32] { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signable_hash(); ret } -/// InvoiceSignature for the invoice. +/// Signature for the invoice. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_signature(this_arg: &SignedRawInvoice) -> crate::lightning_invoice::InvoiceSignature { +pub extern "C" fn SignedRawInvoice_signature(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> crate::lightning_invoice::InvoiceSignature { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signature(); crate::lightning_invoice::InvoiceSignature { inner: unsafe { ObjOps::nonnull_ptr_to_inner((ret as *const lightning_invoice::InvoiceSignature<>) as *mut _) }, is_owned: false } } @@ -1639,7 +2179,7 @@ pub extern "C" fn SignedRawInvoice_signature(this_arg: &SignedRawInvoice) -> cra /// Recovers the public key used for signing the invoice from the recoverable signature. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_recover_payee_pub_key(this_arg: &SignedRawInvoice) -> crate::c_types::derived::CResult_PayeePubKeyErrorZ { +pub extern "C" fn SignedRawInvoice_recover_payee_pub_key(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> crate::c_types::derived::CResult_PayeePubKeyErrorZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.recover_payee_pub_key(); let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::PayeePubKey { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }).into() }; local_ret @@ -1649,16 +2189,16 @@ pub extern "C" fn SignedRawInvoice_recover_payee_pub_key(this_arg: &SignedRawInv /// valid for the recovered signature (which should always be true?). #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_check_signature(this_arg: &SignedRawInvoice) -> bool { +pub extern "C" fn SignedRawInvoice_check_signature(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> bool { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.check_signature(); ret } -/// Calculate the hash of the encoded `RawInvoice` +/// Calculate the hash of the encoded `RawInvoice` which should be signed. #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_hash(this_arg: &RawInvoice) -> crate::c_types::ThirtyTwoBytes { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.hash(); +pub extern "C" fn RawInvoice_signable_hash(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::ThirtyTwoBytes { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signable_hash(); crate::c_types::ThirtyTwoBytes { data: ret } } @@ -1666,7 +2206,7 @@ pub extern "C" fn RawInvoice_hash(this_arg: &RawInvoice) -> crate::c_types::Thir /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_payment_hash(this_arg: &RawInvoice) -> crate::lightning_invoice::Sha256 { +pub extern "C" fn RawInvoice_payment_hash(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Sha256 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_hash(); let mut local_ret = crate::lightning_invoice::Sha256 { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::Sha256<>) as *mut _ }, is_owned: false }; local_ret @@ -1676,7 +2216,7 @@ pub extern "C" fn RawInvoice_payment_hash(this_arg: &RawInvoice) -> crate::light /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_description(this_arg: &RawInvoice) -> crate::lightning_invoice::Description { +pub extern "C" fn RawInvoice_description(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Description { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.description(); let mut local_ret = crate::lightning_invoice::Description { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::Description<>) as *mut _ }, is_owned: false }; local_ret @@ -1686,7 +2226,7 @@ pub extern "C" fn RawInvoice_description(this_arg: &RawInvoice) -> crate::lightn /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_payee_pub_key(this_arg: &RawInvoice) -> crate::lightning_invoice::PayeePubKey { +pub extern "C" fn RawInvoice_payee_pub_key(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::PayeePubKey { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payee_pub_key(); let mut local_ret = crate::lightning_invoice::PayeePubKey { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::PayeePubKey<>) as *mut _ }, is_owned: false }; local_ret @@ -1696,7 +2236,7 @@ pub extern "C" fn RawInvoice_payee_pub_key(this_arg: &RawInvoice) -> crate::ligh /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_description_hash(this_arg: &RawInvoice) -> crate::lightning_invoice::Sha256 { +pub extern "C" fn RawInvoice_description_hash(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Sha256 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.description_hash(); let mut local_ret = crate::lightning_invoice::Sha256 { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::Sha256<>) as *mut _ }, is_owned: false }; local_ret @@ -1706,7 +2246,7 @@ pub extern "C" fn RawInvoice_description_hash(this_arg: &RawInvoice) -> crate::l /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_expiry_time(this_arg: &RawInvoice) -> crate::lightning_invoice::ExpiryTime { +pub extern "C" fn RawInvoice_expiry_time(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::ExpiryTime { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expiry_time(); let mut local_ret = crate::lightning_invoice::ExpiryTime { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::ExpiryTime<>) as *mut _ }, is_owned: false }; local_ret @@ -1716,9 +2256,9 @@ pub extern "C" fn RawInvoice_expiry_time(this_arg: &RawInvoice) -> crate::lightn /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_min_final_cltv_expiry(this_arg: &RawInvoice) -> crate::lightning_invoice::MinFinalCltvExpiry { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.min_final_cltv_expiry(); - let mut local_ret = crate::lightning_invoice::MinFinalCltvExpiry { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::MinFinalCltvExpiry<>) as *mut _ }, is_owned: false }; +pub extern "C" fn RawInvoice_min_final_cltv_expiry_delta(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::MinFinalCltvExpiryDelta { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.min_final_cltv_expiry_delta(); + let mut local_ret = crate::lightning_invoice::MinFinalCltvExpiryDelta { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_invoice::MinFinalCltvExpiryDelta<>) as *mut _ }, is_owned: false }; local_ret } @@ -1726,17 +2266,25 @@ pub extern "C" fn RawInvoice_min_final_cltv_expiry(this_arg: &RawInvoice) -> cra /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_payment_secret(this_arg: &RawInvoice) -> crate::c_types::ThirtyTwoBytes { +pub extern "C" fn RawInvoice_payment_secret(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::ThirtyTwoBytes { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_secret(); let mut local_ret = if ret.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (ret.unwrap()).0 } } }; local_ret } +#[must_use] +#[no_mangle] +pub extern "C" fn RawInvoice_payment_metadata(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::derived::COption_CVec_u8ZZ { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_metadata(); + let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */ { let mut local_ret_0 = Vec::new(); for mut item in (*ret.as_ref().unwrap()).clone().drain(..) { local_ret_0.push( { item }); }; local_ret_0.into() }) }; + local_ret +} + /// /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_features(this_arg: &RawInvoice) -> crate::lightning::ln::features::InvoiceFeatures { +pub extern "C" fn RawInvoice_features(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning::ln::features::InvoiceFeatures { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.features(); let mut local_ret = crate::lightning::ln::features::InvoiceFeatures { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning::ln::features::InvoiceFeatures<>) as *mut _ }, is_owned: false }; local_ret @@ -1744,7 +2292,7 @@ pub extern "C" fn RawInvoice_features(this_arg: &RawInvoice) -> crate::lightning #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_private_routes(this_arg: &RawInvoice) -> crate::c_types::derived::CVec_PrivateRouteZ { +pub extern "C" fn RawInvoice_private_routes(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::derived::CVec_PrivateRouteZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.private_routes(); let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { crate::lightning_invoice::PrivateRoute { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning_invoice::PrivateRoute<>) as *mut _) }, is_owned: false } }); }; local_ret.into() @@ -1752,7 +2300,7 @@ pub extern "C" fn RawInvoice_private_routes(this_arg: &RawInvoice) -> crate::c_t #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_amount_pico_btc(this_arg: &RawInvoice) -> crate::c_types::derived::COption_u64Z { +pub extern "C" fn RawInvoice_amount_pico_btc(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::derived::COption_u64Z { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.amount_pico_btc(); let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { ret.unwrap() }) }; local_ret @@ -1760,7 +2308,7 @@ pub extern "C" fn RawInvoice_amount_pico_btc(this_arg: &RawInvoice) -> crate::c_ #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_currency(this_arg: &RawInvoice) -> crate::lightning_invoice::Currency { +pub extern "C" fn RawInvoice_currency(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Currency { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.currency(); crate::lightning_invoice::Currency::native_into(ret) } @@ -1779,6 +2327,8 @@ pub extern "C" fn PositiveTimestamp_from_unix_timestamp(mut unix_seconds: u64) - /// Creates a `PositiveTimestamp` from a [`SystemTime`] with a corresponding Unix timestamp in /// the range `0..=MAX_TIMESTAMP`. /// +/// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices. +/// /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`]. #[must_use] #[no_mangle] @@ -1791,6 +2341,8 @@ pub extern "C" fn PositiveTimestamp_from_system_time(mut time: u64) -> crate::c_ /// Creates a `PositiveTimestamp` from a [`Duration`] since the Unix epoch in the range /// `0..=MAX_TIMESTAMP`. /// +/// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices. +/// /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`]. #[must_use] #[no_mangle] @@ -1803,7 +2355,7 @@ pub extern "C" fn PositiveTimestamp_from_duration_since_epoch(mut duration: u64) /// Returns the Unix timestamp representing the stored time #[must_use] #[no_mangle] -pub extern "C" fn PositiveTimestamp_as_unix_timestamp(this_arg: &PositiveTimestamp) -> u64 { +pub extern "C" fn PositiveTimestamp_as_unix_timestamp(this_arg: &crate::lightning_invoice::PositiveTimestamp) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.as_unix_timestamp(); ret } @@ -1811,7 +2363,7 @@ pub extern "C" fn PositiveTimestamp_as_unix_timestamp(this_arg: &PositiveTimesta /// Returns the duration of the stored time since the Unix epoch #[must_use] #[no_mangle] -pub extern "C" fn PositiveTimestamp_as_duration_since_epoch(this_arg: &PositiveTimestamp) -> u64 { +pub extern "C" fn PositiveTimestamp_as_duration_since_epoch(this_arg: &crate::lightning_invoice::PositiveTimestamp) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.as_duration_since_epoch(); ret.as_secs() } @@ -1819,15 +2371,23 @@ pub extern "C" fn PositiveTimestamp_as_duration_since_epoch(this_arg: &PositiveT /// Returns the [`SystemTime`] representing the stored time #[must_use] #[no_mangle] -pub extern "C" fn PositiveTimestamp_as_time(this_arg: &PositiveTimestamp) -> u64 { +pub extern "C" fn PositiveTimestamp_as_time(this_arg: &crate::lightning_invoice::PositiveTimestamp) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.as_time(); ret.duration_since(::std::time::SystemTime::UNIX_EPOCH).expect("Times must be post-1970").as_secs() } +/// The hash of the [`RawInvoice`] that was signed. +#[must_use] +#[no_mangle] +pub extern "C" fn Invoice_signable_hash(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::ThirtyTwoBytes { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signable_hash(); + crate::c_types::ThirtyTwoBytes { data: ret } +} + /// Transform the `Invoice` into it's unchecked version #[must_use] #[no_mangle] -pub extern "C" fn Invoice_into_signed_raw(mut this_arg: Invoice) -> crate::lightning_invoice::SignedRawInvoice { +pub extern "C" fn Invoice_into_signed_raw(mut this_arg: crate::lightning_invoice::Invoice) -> crate::lightning_invoice::SignedRawInvoice { let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_signed_raw(); crate::lightning_invoice::SignedRawInvoice { inner: ObjOps::heap_alloc(ret), is_owned: true } } @@ -1835,13 +2395,13 @@ pub extern "C" fn Invoice_into_signed_raw(mut this_arg: Invoice) -> crate::light /// Check that the invoice is signed correctly and that key recovery works #[must_use] #[no_mangle] -pub extern "C" fn Invoice_check_signature(this_arg: &Invoice) -> crate::c_types::derived::CResult_NoneSemanticErrorZ { +pub extern "C" fn Invoice_check_signature(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CResult_NoneSemanticErrorZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.check_signature(); let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SemanticError::native_into(e) }).into() }; local_ret } -/// Constructs an `Invoice` from a `SignedRawInvoice` by checking all its invariants. +/// Constructs an `Invoice` from a [`SignedRawInvoice`] by checking all its invariants. /// ``` /// use lightning_invoice::*; /// @@ -1872,7 +2432,7 @@ pub extern "C" fn Invoice_from_signed(mut signed_invoice: crate::lightning_invoi /// Returns the `Invoice`'s timestamp (should equal its creation time) #[must_use] #[no_mangle] -pub extern "C" fn Invoice_timestamp(this_arg: &Invoice) -> u64 { +pub extern "C" fn Invoice_timestamp(this_arg: &crate::lightning_invoice::Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.timestamp(); ret.duration_since(::std::time::SystemTime::UNIX_EPOCH).expect("Times must be post-1970").as_secs() } @@ -1880,7 +2440,7 @@ pub extern "C" fn Invoice_timestamp(this_arg: &Invoice) -> u64 { /// Returns the `Invoice`'s timestamp as a duration since the Unix epoch #[must_use] #[no_mangle] -pub extern "C" fn Invoice_duration_since_epoch(this_arg: &Invoice) -> u64 { +pub extern "C" fn Invoice_duration_since_epoch(this_arg: &crate::lightning_invoice::Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.duration_since_epoch(); ret.as_secs() } @@ -1888,7 +2448,7 @@ pub extern "C" fn Invoice_duration_since_epoch(this_arg: &Invoice) -> u64 { /// Returns the hash to which we will receive the preimage on completion of the payment #[must_use] #[no_mangle] -pub extern "C" fn Invoice_payment_hash(this_arg: &Invoice) -> *const [u8; 32] { +pub extern "C" fn Invoice_payment_hash(this_arg: &crate::lightning_invoice::Invoice) -> *const [u8; 32] { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_hash(); ret.as_inner() } @@ -1898,7 +2458,7 @@ pub extern "C" fn Invoice_payment_hash(this_arg: &Invoice) -> *const [u8; 32] { /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn Invoice_payee_pub_key(this_arg: &Invoice) -> crate::c_types::PublicKey { +pub extern "C" fn Invoice_payee_pub_key(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::PublicKey { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payee_pub_key(); let mut local_ret = if ret.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(ret.unwrap())) } }; local_ret @@ -1907,17 +2467,26 @@ pub extern "C" fn Invoice_payee_pub_key(this_arg: &Invoice) -> crate::c_types::P /// Get the payment secret if one was included in the invoice #[must_use] #[no_mangle] -pub extern "C" fn Invoice_payment_secret(this_arg: &Invoice) -> *const [u8; 32] { +pub extern "C" fn Invoice_payment_secret(this_arg: &crate::lightning_invoice::Invoice) -> *const [u8; 32] { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_secret(); &ret.0 } +/// Get the payment metadata blob if one was included in the invoice +#[must_use] +#[no_mangle] +pub extern "C" fn Invoice_payment_metadata(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::COption_CVec_u8ZZ { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_metadata(); + let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */ { let mut local_ret_0 = Vec::new(); for mut item in (*ret.as_ref().unwrap()).clone().drain(..) { local_ret_0.push( { item }); }; local_ret_0.into() }) }; + local_ret +} + /// Get the invoice features if they were included in the invoice /// /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn Invoice_features(this_arg: &Invoice) -> crate::lightning::ln::features::InvoiceFeatures { +pub extern "C" fn Invoice_features(this_arg: &crate::lightning_invoice::Invoice) -> crate::lightning::ln::features::InvoiceFeatures { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.features(); let mut local_ret = crate::lightning::ln::features::InvoiceFeatures { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning::ln::features::InvoiceFeatures<>) as *mut _ }, is_owned: false }; local_ret @@ -1926,15 +2495,25 @@ pub extern "C" fn Invoice_features(this_arg: &Invoice) -> crate::lightning::ln:: /// Recover the payee's public key (only to be used if none was included in the invoice) #[must_use] #[no_mangle] -pub extern "C" fn Invoice_recover_payee_pub_key(this_arg: &Invoice) -> crate::c_types::PublicKey { +pub extern "C" fn Invoice_recover_payee_pub_key(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::PublicKey { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.recover_payee_pub_key(); crate::c_types::PublicKey::from_rust(&ret) } +/// Returns the Duration since the Unix epoch at which the invoice expires. +/// Returning None if overflow occurred. +#[must_use] +#[no_mangle] +pub extern "C" fn Invoice_expires_at(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::COption_DurationZ { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expires_at(); + let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_DurationZ::None } else { crate::c_types::derived::COption_DurationZ::Some( { ret.unwrap().as_secs() }) }; + local_ret +} + /// Returns the invoice's expiry time, if present, otherwise [`DEFAULT_EXPIRY_TIME`]. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_expiry_time(this_arg: &Invoice) -> u64 { +pub extern "C" fn Invoice_expiry_time(this_arg: &crate::lightning_invoice::Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expiry_time(); ret.as_secs() } @@ -1942,33 +2521,59 @@ pub extern "C" fn Invoice_expiry_time(this_arg: &Invoice) -> u64 { /// Returns whether the invoice has expired. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_is_expired(this_arg: &Invoice) -> bool { +pub extern "C" fn Invoice_is_expired(this_arg: &crate::lightning_invoice::Invoice) -> bool { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.is_expired(); ret } +/// Returns the Duration remaining until the invoice expires. +#[must_use] +#[no_mangle] +pub extern "C" fn Invoice_duration_until_expiry(this_arg: &crate::lightning_invoice::Invoice) -> u64 { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.duration_until_expiry(); + ret.as_secs() +} + +/// Returns the Duration remaining until the invoice expires given the current time. +/// `time` is the timestamp as a duration since the Unix epoch. +#[must_use] +#[no_mangle] +pub extern "C" fn Invoice_expiration_remaining_from_epoch(this_arg: &crate::lightning_invoice::Invoice, mut time: u64) -> u64 { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expiration_remaining_from_epoch(core::time::Duration::from_secs(time)); + ret.as_secs() +} + /// Returns whether the expiry time would pass at the given point in time. /// `at_time` is the timestamp as a duration since the Unix epoch. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_would_expire(this_arg: &Invoice, mut at_time: u64) -> bool { +pub extern "C" fn Invoice_would_expire(this_arg: &crate::lightning_invoice::Invoice, mut at_time: u64) -> bool { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.would_expire(core::time::Duration::from_secs(at_time)); ret } -/// Returns the invoice's `min_final_cltv_expiry` time, if present, otherwise -/// [`DEFAULT_MIN_FINAL_CLTV_EXPIRY`]. +/// Returns the invoice's `min_final_cltv_expiry_delta` time, if present, otherwise +/// [`DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA`]. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_min_final_cltv_expiry(this_arg: &Invoice) -> u64 { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.min_final_cltv_expiry(); +pub extern "C" fn Invoice_min_final_cltv_expiry_delta(this_arg: &crate::lightning_invoice::Invoice) -> u64 { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.min_final_cltv_expiry_delta(); ret } +/// Returns a list of all fallback addresses as [`Address`]es +#[must_use] +#[no_mangle] +pub extern "C" fn Invoice_fallback_addresses(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CVec_AddressZ { + let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.fallback_addresses(); + let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { alloc::string::ToString::to_string(&item).into() }); }; + local_ret.into() +} + /// Returns a list of all routes included in the invoice #[must_use] #[no_mangle] -pub extern "C" fn Invoice_private_routes(this_arg: &Invoice) -> crate::c_types::derived::CVec_PrivateRouteZ { +pub extern "C" fn Invoice_private_routes(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CVec_PrivateRouteZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.private_routes(); let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { crate::lightning_invoice::PrivateRoute { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning_invoice::PrivateRoute<>) as *mut _) }, is_owned: false } }); }; local_ret.into() @@ -1977,7 +2582,7 @@ pub extern "C" fn Invoice_private_routes(this_arg: &Invoice) -> crate::c_types:: /// Returns a list of all routes included in the invoice as the underlying hints #[must_use] #[no_mangle] -pub extern "C" fn Invoice_route_hints(this_arg: &Invoice) -> crate::c_types::derived::CVec_RouteHintZ { +pub extern "C" fn Invoice_route_hints(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CVec_RouteHintZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.route_hints(); let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { crate::lightning::routing::router::RouteHint { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; local_ret.into() @@ -1986,7 +2591,7 @@ pub extern "C" fn Invoice_route_hints(this_arg: &Invoice) -> crate::c_types::der /// Returns the currency for which the invoice was issued #[must_use] #[no_mangle] -pub extern "C" fn Invoice_currency(this_arg: &Invoice) -> crate::lightning_invoice::Currency { +pub extern "C" fn Invoice_currency(this_arg: &crate::lightning_invoice::Invoice) -> crate::lightning_invoice::Currency { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.currency(); crate::lightning_invoice::Currency::native_into(ret) } @@ -1994,14 +2599,14 @@ pub extern "C" fn Invoice_currency(this_arg: &Invoice) -> crate::lightning_invoi /// Returns the amount if specified in the invoice as millisatoshis. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_amount_milli_satoshis(this_arg: &Invoice) -> crate::c_types::derived::COption_u64Z { +pub extern "C" fn Invoice_amount_milli_satoshis(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::COption_u64Z { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.amount_milli_satoshis(); let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { ret.unwrap() }) }; local_ret } /// Creates a new `Description` if `description` is at most 1023 __bytes__ long, -/// returns `CreationError::DescriptionTooLong` otherwise +/// returns [`CreationError::DescriptionTooLong`] otherwise /// /// Please note that single characters may use more than one byte due to UTF8 encoding. #[must_use] @@ -2012,10 +2617,10 @@ pub extern "C" fn Description_new(mut description: crate::c_types::Str) -> crate local_ret } -/// Returns the underlying description `String` +/// Returns the underlying description [`String`] #[must_use] #[no_mangle] -pub extern "C" fn Description_into_inner(mut this_arg: Description) -> crate::c_types::Str { +pub extern "C" fn Description_into_inner(mut this_arg: crate::lightning_invoice::Description) -> crate::c_types::Str { let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_inner(); ret.into() } @@ -2028,7 +2633,7 @@ pub extern "C" fn ExpiryTime_from_seconds(mut seconds: u64) -> crate::lightning_ crate::lightning_invoice::ExpiryTime { inner: ObjOps::heap_alloc(ret), is_owned: true } } -/// Construct an `ExpiryTime` from a `Duration`. +/// Construct an `ExpiryTime` from a [`Duration`], dropping the sub-second part. #[must_use] #[no_mangle] pub extern "C" fn ExpiryTime_from_duration(mut duration: u64) -> crate::lightning_invoice::ExpiryTime { @@ -2039,15 +2644,15 @@ pub extern "C" fn ExpiryTime_from_duration(mut duration: u64) -> crate::lightnin /// Returns the expiry time in seconds #[must_use] #[no_mangle] -pub extern "C" fn ExpiryTime_as_seconds(this_arg: &ExpiryTime) -> u64 { +pub extern "C" fn ExpiryTime_as_seconds(this_arg: &crate::lightning_invoice::ExpiryTime) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.as_seconds(); ret } -/// Returns a reference to the underlying `Duration` (=expiry time) +/// Returns a reference to the underlying [`Duration`] (=expiry time) #[must_use] #[no_mangle] -pub extern "C" fn ExpiryTime_as_duration(this_arg: &ExpiryTime) -> u64 { +pub extern "C" fn ExpiryTime_as_duration(this_arg: &crate::lightning_invoice::ExpiryTime) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.as_duration(); ret.as_secs() } @@ -2064,17 +2669,17 @@ pub extern "C" fn PrivateRoute_new(mut hops: crate::lightning::routing::router:: /// Returns the underlying list of hops #[must_use] #[no_mangle] -pub extern "C" fn PrivateRoute_into_inner(mut this_arg: PrivateRoute) -> crate::lightning::routing::router::RouteHint { +pub extern "C" fn PrivateRoute_into_inner(mut this_arg: crate::lightning_invoice::PrivateRoute) -> crate::lightning::routing::router::RouteHint { let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_inner(); crate::lightning::routing::router::RouteHint { inner: ObjOps::heap_alloc(ret), is_owned: true } } -/// Errors that may occur when constructing a new `RawInvoice` or `Invoice` -#[must_use] +/// Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`] #[derive(Clone)] +#[must_use] #[repr(C)] pub enum CreationError { - /// The supplied description string was longer than 639 __bytes__ (see [`Description::new(…)`](./struct.Description.html#method.new)) + /// The supplied description string was longer than 639 __bytes__ (see [`Description::new`]) DescriptionTooLong, /// The specified route has too many hops and can't be encoded RouteTooLong, @@ -2087,8 +2692,14 @@ pub enum CreationError { /// /// [phantom invoices]: crate::utils::create_phantom_invoice MissingRouteHints, + /// The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`]. + /// + /// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA + MinFinalCltvExpiryDeltaTooShort, } -use lightning_invoice::CreationError as nativeCreationError; +use lightning_invoice::CreationError as CreationErrorImport; +pub(crate) type nativeCreationError = CreationErrorImport; + impl CreationError { #[allow(unused)] pub(crate) fn to_native(&self) -> nativeCreationError { @@ -2098,6 +2709,7 @@ impl CreationError { CreationError::TimestampOutOfBounds => nativeCreationError::TimestampOutOfBounds, CreationError::InvalidAmount => nativeCreationError::InvalidAmount, CreationError::MissingRouteHints => nativeCreationError::MissingRouteHints, + CreationError::MinFinalCltvExpiryDeltaTooShort => nativeCreationError::MinFinalCltvExpiryDeltaTooShort, } } #[allow(unused)] @@ -2108,6 +2720,7 @@ impl CreationError { CreationError::TimestampOutOfBounds => nativeCreationError::TimestampOutOfBounds, CreationError::InvalidAmount => nativeCreationError::InvalidAmount, CreationError::MissingRouteHints => nativeCreationError::MissingRouteHints, + CreationError::MinFinalCltvExpiryDeltaTooShort => nativeCreationError::MinFinalCltvExpiryDeltaTooShort, } } #[allow(unused)] @@ -2118,6 +2731,7 @@ impl CreationError { nativeCreationError::TimestampOutOfBounds => CreationError::TimestampOutOfBounds, nativeCreationError::InvalidAmount => CreationError::InvalidAmount, nativeCreationError::MissingRouteHints => CreationError::MissingRouteHints, + nativeCreationError::MinFinalCltvExpiryDeltaTooShort => CreationError::MinFinalCltvExpiryDeltaTooShort, } } #[allow(unused)] @@ -2128,6 +2742,7 @@ impl CreationError { nativeCreationError::TimestampOutOfBounds => CreationError::TimestampOutOfBounds, nativeCreationError::InvalidAmount => CreationError::InvalidAmount, nativeCreationError::MissingRouteHints => CreationError::MissingRouteHints, + nativeCreationError::MinFinalCltvExpiryDeltaTooShort => CreationError::MinFinalCltvExpiryDeltaTooShort, } } } @@ -2156,6 +2771,10 @@ pub extern "C" fn CreationError_invalid_amount() -> CreationError { /// Utility method to constructs a new MissingRouteHints-variant CreationError pub extern "C" fn CreationError_missing_route_hints() -> CreationError { CreationError::MissingRouteHints} +#[no_mangle] +/// Utility method to constructs a new MinFinalCltvExpiryDeltaTooShort-variant CreationError +pub extern "C" fn CreationError_min_final_cltv_expiry_delta_too_short() -> CreationError { + CreationError::MinFinalCltvExpiryDeltaTooShort} /// Checks if two CreationErrors contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] @@ -2167,10 +2786,10 @@ pub extern "C" fn CreationError_eq(a: &CreationError, b: &CreationError) -> bool pub extern "C" fn CreationError_to_str(o: &crate::lightning_invoice::CreationError) -> Str { alloc::format!("{}", &o.to_native()).into() } -/// Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the +/// Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`]. They relate to the /// requirements sections in BOLT #11 -#[must_use] #[derive(Clone)] +#[must_use] #[repr(C)] pub enum SemanticError { /// The invoice is missing the mandatory payment hash @@ -2195,7 +2814,9 @@ pub enum SemanticError { /// The invoice's amount was not a whole number of millisatoshis ImpreciseAmount, } -use lightning_invoice::SemanticError as nativeSemanticError; +use lightning_invoice::SemanticError as SemanticErrorImport; +pub(crate) type nativeSemanticError = SemanticErrorImport; + impl SemanticError { #[allow(unused)] pub(crate) fn to_native(&self) -> nativeSemanticError { @@ -2314,18 +2935,21 @@ pub extern "C" fn SemanticError_eq(a: &SemanticError, b: &SemanticError) -> bool pub extern "C" fn SemanticError_to_str(o: &crate::lightning_invoice::SemanticError) -> Str { alloc::format!("{}", &o.to_native()).into() } -/// When signing using a fallible method either an user-supplied `SignError` or a `CreationError` +/// When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`] /// may occur. -#[must_use] #[derive(Clone)] +#[must_use] #[repr(C)] pub enum SignOrCreationError { /// An error occurred during signing SignError, /// An error occurred while building the transaction - CreationError(crate::lightning_invoice::CreationError), + CreationError( + crate::lightning_invoice::CreationError), } -use lightning_invoice::SignOrCreationError as nativeSignOrCreationError; +use lightning_invoice::SignOrCreationError as SignOrCreationErrorImport; +pub(crate) type nativeSignOrCreationError = SignOrCreationErrorImport<>; + impl SignOrCreationError { #[allow(unused)] pub(crate) fn to_native(&self) -> nativeSignOrCreationError { @@ -2336,7 +2960,7 @@ impl SignOrCreationError { ) }, SignOrCreationError::CreationError (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); nativeSignOrCreationError::CreationError ( a_nonref.into_native(), ) @@ -2364,7 +2988,7 @@ impl SignOrCreationError { nativeSignOrCreationError::SignError (ref a, ) => { SignOrCreationError::SignError }, nativeSignOrCreationError::CreationError (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); SignOrCreationError::CreationError ( crate::lightning_invoice::CreationError::native_into(a_nonref), )