Update auto-generated bindings
[ldk-c-bindings] / lightning-c-bindings / src / lightning_invoice / mod.rs
index 4afdd97ce0f8d46734a9baaaad527c3ac519b1b6..4b12f320c9fe1c94ad7b5bcd2f5f6efddafacd95 100644 (file)
@@ -7,7 +7,7 @@
 // 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:
 //!
@@ -26,6 +26,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;
@@ -172,50 +183,57 @@ 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.
-#[must_use]
 #[derive(Clone)]
+#[must_use]
 #[repr(C)]
 pub enum ParseError {
-       Bech32Error(crate::c_types::Bech32Error),
-       ParseAmountError(crate::c_types::Error),
-       MalformedSignature(crate::c_types::Secp256k1Error),
+       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),
+       DescriptionDecodeError(
+               crate::c_types::Error),
        PaddingError,
        IntegerOverflowError,
        InvalidSegWitProgramLength,
        InvalidPubKeyHashLength,
        InvalidScriptHashLength,
        InvalidRecoveryId,
-       InvalidSliceLength(crate::c_types::Str),
+       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 nativeParseError;
+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 = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeParseError::Bech32Error (
                                        a_nonref.into_rust(),
                                )
                        },
                        ParseError::ParseAmountError (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               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 = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeParseError::MalformedSignature (
                                        a_nonref.into_rust(),
                                )
@@ -227,7 +245,7 @@ impl ParseError {
                        ParseError::TooShortDataPart => nativeParseError::TooShortDataPart,
                        ParseError::UnexpectedEndOfTaggedFields => nativeParseError::UnexpectedEndOfTaggedFields,
                        ParseError::DescriptionDecodeError (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeParseError::DescriptionDecodeError (
                                        core::str::from_utf8(&[0xff]).unwrap_err() /*a_nonref*/,
                                )
@@ -239,7 +257,7 @@ impl ParseError {
                        ParseError::InvalidScriptHashLength => nativeParseError::InvalidScriptHashLength,
                        ParseError::InvalidRecoveryId => nativeParseError::InvalidRecoveryId,
                        ParseError::InvalidSliceLength (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeParseError::InvalidSliceLength (
                                        a_nonref.into_string(),
                                )
@@ -294,19 +312,19 @@ impl ParseError {
        pub(crate) fn from_native(native: &nativeParseError) -> Self {
                match native {
                        nativeParseError::Bech32Error (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               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 = (*a).clone();
+                               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 = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                ParseError::MalformedSignature (
                                        crate::c_types::Secp256k1Error::from_rust(a_nonref),
                                )
@@ -318,7 +336,7 @@ impl ParseError {
                        nativeParseError::TooShortDataPart => ParseError::TooShortDataPart,
                        nativeParseError::UnexpectedEndOfTaggedFields => ParseError::UnexpectedEndOfTaggedFields,
                        nativeParseError::DescriptionDecodeError (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                ParseError::DescriptionDecodeError (
                                        crate::c_types::Error { _dummy: 0 } /*a_nonref*/,
                                )
@@ -330,7 +348,7 @@ impl ParseError {
                        nativeParseError::InvalidScriptHashLength => ParseError::InvalidScriptHashLength,
                        nativeParseError::InvalidRecoveryId => ParseError::InvalidRecoveryId,
                        nativeParseError::InvalidSliceLength (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                ParseError::InvalidSliceLength (
                                        a_nonref.into(),
                                )
@@ -467,31 +485,41 @@ pub extern "C" fn ParseError_invalid_slice_length(a: crate::c_types::Str) -> Par
 /// 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.
-#[must_use]
 #[derive(Clone)]
+#[must_use]
 #[repr(C)]
 pub enum ParseOrSemanticError {
        /// The invoice couldn't be decoded
-       ParseError(crate::lightning_invoice::ParseError),
+       ParseError(
+               crate::lightning_invoice::ParseError),
        /// The invoice could be decoded but violates the BOLT11 standard
-       SemanticError(crate::lightning_invoice::SemanticError),
+       SemanticError(
+               crate::lightning_invoice::SemanticError),
 }
-use lightning_invoice::ParseOrSemanticError as nativeParseOrSemanticError;
+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 = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeParseOrSemanticError::ParseError (
                                        a_nonref.into_native(),
                                )
                        },
                        ParseOrSemanticError::SemanticError (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeParseOrSemanticError::SemanticError (
                                        a_nonref.into_native(),
                                )
@@ -517,13 +545,13 @@ impl ParseOrSemanticError {
        pub(crate) fn from_native(native: &nativeParseOrSemanticError) -> Self {
                match native {
                        nativeParseOrSemanticError::ParseError (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               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 = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                ParseOrSemanticError::SemanticError (
                                        crate::lightning_invoice::SemanticError::native_into(a_nonref),
                                )
@@ -564,6 +592,12 @@ pub extern "C" fn ParseOrSemanticError_parse_error(a: crate::lightning_invoice::
 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`].
 ///
 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
@@ -579,13 +613,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;
@@ -624,7 +658,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 {
@@ -670,6 +704,16 @@ 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()
 }
+/// Checks if two Invoices contain equal inner contents.
+#[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;
@@ -707,7 +751,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 {
@@ -753,6 +797,16 @@ pub(crate) extern "C" fn SignedRawInvoice_clone_void(this_ptr: *const c_void) ->
 pub extern "C" fn SignedRawInvoice_clone(orig: &SignedRawInvoice) -> SignedRawInvoice {
        orig.clone()
 }
+/// Checks if two SignedRawInvoices contain equal inner contents.
+#[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;
@@ -790,7 +844,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 {
@@ -847,6 +901,16 @@ 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()
 }
+/// Checks if two RawInvoices contain equal inner contents.
+#[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;
@@ -880,7 +944,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 {
@@ -937,6 +1001,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()
 }
+/// Checks if two RawDataParts contain equal inner contents.
+#[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;
@@ -975,7 +1049,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 {
@@ -1021,9 +1095,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()
 }
+/// Checks if two PositiveTimestamps contain equal inner contents.
+#[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
@@ -1035,7 +1119,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 {
@@ -1101,18 +1187,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 }
 }
+/// Checks if two SiPrefixs contain equal inner contents.
+#[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
@@ -1126,7 +1221,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 {
@@ -1242,7 +1339,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 {
@@ -1334,7 +1431,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 {
@@ -1423,7 +1520,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 {
@@ -1530,7 +1627,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 {
@@ -1587,18 +1684,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
@@ -1606,31 +1703,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();
@@ -1638,26 +1735,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,
                }
@@ -1665,17 +1762,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.
+/// Checks if two MinFinalCltvExpiryDeltas contain equal inner contents.
 #[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)]
@@ -1683,35 +1780,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::U5,
                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(),
@@ -1719,13 +1820,13 @@ impl Fallback {
                                }
                        },
                        Fallback::PubKeyHash (ref a, ) => {
-                               let mut a_nonref = (*a).clone();
+                               let mut a_nonref = Clone::clone(a);
                                nativeFallback::PubKeyHash (
                                        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,
                                )
@@ -1758,8 +1859,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(),
@@ -1767,13 +1868,13 @@ 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 },
                                )
                        },
                        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 },
                                )
@@ -1813,7 +1914,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::U5, program: crate::c_types::derived::CVec_u8Z) -> Fallback {
        Fallback::SegWitProgram {
                version,
                program,
@@ -1877,7 +1978,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 {
@@ -1915,6 +2016,16 @@ pub extern "C" fn InvoiceSignature_clone(orig: &InvoiceSignature) -> InvoiceSign
        orig.clone()
 }
 /// Checks if two InvoiceSignatures contain equal inner contents.
+#[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.
 #[no_mangle]
@@ -1960,7 +2071,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 {
@@ -2022,7 +2133,7 @@ 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
@@ -2031,7 +2142,7 @@ pub extern "C" fn SignedRawInvoice_into_parts(mut this_arg: SignedRawInvoice) ->
 /// 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 }
 }
@@ -2039,15 +2150,15 @@ pub extern "C" fn SignedRawInvoice_raw_invoice(this_arg: &SignedRawInvoice) -> c
 /// 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.
 #[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 }
 }
@@ -2055,7 +2166,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
@@ -2065,16 +2176,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 }
 }
 
@@ -2082,7 +2193,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
@@ -2092,7 +2203,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
@@ -2102,7 +2213,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
@@ -2112,7 +2223,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
@@ -2122,7 +2233,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
@@ -2132,9 +2243,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
 }
 
@@ -2142,7 +2253,7 @@ 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
@@ -2152,7 +2263,7 @@ pub extern "C" fn RawInvoice_payment_secret(this_arg: &RawInvoice) -> crate::c_t
 /// 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
@@ -2160,7 +2271,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()
@@ -2168,7 +2279,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
@@ -2176,7 +2287,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)
 }
@@ -2195,6 +2306,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]
@@ -2207,6 +2320,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]
@@ -2219,7 +2334,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
 }
@@ -2227,7 +2342,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()
 }
@@ -2235,7 +2350,7 @@ 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()
 }
@@ -2243,7 +2358,7 @@ pub extern "C" fn PositiveTimestamp_as_time(this_arg: &PositiveTimestamp) -> u64
 /// 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 }
 }
@@ -2251,7 +2366,7 @@ 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
@@ -2288,7 +2403,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()
 }
@@ -2296,7 +2411,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()
 }
@@ -2304,7 +2419,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()
 }
@@ -2314,7 +2429,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
@@ -2323,7 +2438,7 @@ 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
 }
@@ -2333,7 +2448,7 @@ pub extern "C" fn Invoice_payment_secret(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_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
@@ -2342,7 +2457,7 @@ 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)
 }
@@ -2350,7 +2465,7 @@ pub extern "C" fn Invoice_recover_payee_pub_key(this_arg: &Invoice) -> crate::c_
 /// 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()
 }
@@ -2358,7 +2473,7 @@ 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
 }
@@ -2367,24 +2482,24 @@ pub extern "C" fn Invoice_is_expired(this_arg: &Invoice) -> bool {
 /// `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 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()
@@ -2393,7 +2508,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()
@@ -2402,7 +2517,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)
 }
@@ -2410,7 +2525,7 @@ 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
@@ -2431,7 +2546,7 @@ pub extern "C" fn Description_new(mut description: crate::c_types::Str) -> crate
 /// 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()
 }
@@ -2444,7 +2559,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 {
@@ -2455,7 +2570,7 @@ 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
 }
@@ -2463,7 +2578,7 @@ pub extern "C" fn ExpiryTime_as_seconds(this_arg: &ExpiryTime) -> u64 {
 /// 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()
 }
@@ -2480,14 +2595,14 @@ 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]
 #[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))
@@ -2503,8 +2618,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 {
@@ -2514,6 +2635,7 @@ impl CreationError {
                        CreationError::TimestampOutOfBounds => nativeCreationError::TimestampOutOfBounds,
                        CreationError::InvalidAmount => nativeCreationError::InvalidAmount,
                        CreationError::MissingRouteHints => nativeCreationError::MissingRouteHints,
+                       CreationError::MinFinalCltvExpiryDeltaTooShort => nativeCreationError::MinFinalCltvExpiryDeltaTooShort,
                }
        }
        #[allow(unused)]
@@ -2524,6 +2646,7 @@ impl CreationError {
                        CreationError::TimestampOutOfBounds => nativeCreationError::TimestampOutOfBounds,
                        CreationError::InvalidAmount => nativeCreationError::InvalidAmount,
                        CreationError::MissingRouteHints => nativeCreationError::MissingRouteHints,
+                       CreationError::MinFinalCltvExpiryDeltaTooShort => nativeCreationError::MinFinalCltvExpiryDeltaTooShort,
                }
        }
        #[allow(unused)]
@@ -2534,6 +2657,7 @@ impl CreationError {
                        nativeCreationError::TimestampOutOfBounds => CreationError::TimestampOutOfBounds,
                        nativeCreationError::InvalidAmount => CreationError::InvalidAmount,
                        nativeCreationError::MissingRouteHints => CreationError::MissingRouteHints,
+                       nativeCreationError::MinFinalCltvExpiryDeltaTooShort => CreationError::MinFinalCltvExpiryDeltaTooShort,
                }
        }
        #[allow(unused)]
@@ -2544,6 +2668,7 @@ impl CreationError {
                        nativeCreationError::TimestampOutOfBounds => CreationError::TimestampOutOfBounds,
                        nativeCreationError::InvalidAmount => CreationError::InvalidAmount,
                        nativeCreationError::MissingRouteHints => CreationError::MissingRouteHints,
+                       nativeCreationError::MinFinalCltvExpiryDeltaTooShort => CreationError::MinFinalCltvExpiryDeltaTooShort,
                }
        }
 }
@@ -2572,6 +2697,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]
@@ -2585,8 +2714,8 @@ pub extern "C" fn CreationError_to_str(o: &crate::lightning_invoice::CreationErr
 }
 /// 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
@@ -2611,7 +2740,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 {
@@ -2732,16 +2863,19 @@ pub extern "C" fn SemanticError_to_str(o: &crate::lightning_invoice::SemanticErr
 }
 /// 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 {
@@ -2752,7 +2886,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(),
                                )
@@ -2780,7 +2914,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),
                                )