Add missing `rustc` `metadata` override for `lightning_types`

[ldk-c-bindings] / lightning-c-bindings / src / lightning_invoice / mod.rs

diff --git a/lightning-c-bindings/src/lightning_invoice/mod.rs b/lightning-c-bindings/src/lightning_invoice/mod.rs
index 931505ac3d88bc9b42b53e41dba22e731f5f8b55..25f6a63c0a46bef4629917e1df58f5e411cd9822 100644 (file)
--- a/lightning-c-bindings/src/lightning_invoice/mod.rs
+++ b/lightning-c-bindings/src/lightning_invoice/mod.rs
@@ -26,8 +26,6 @@ use crate::c_types::*;
 #[cfg(feature="no-std")]
 use alloc::{vec::Vec, boxed::Box};
 
 #[cfg(feature="no-std")]
 use alloc::{vec::Vec, boxed::Box};
 

-pub mod payment;
-pub mod utils;

 pub mod constants;
 mod de {
 
 pub mod constants;
 mod de {
 


@@ -166,18 +164,6 @@ use crate::c_types::*;
 #[cfg(feature="no-std")]
 use alloc::{vec::Vec, boxed::Box};
 
 #[cfg(feature="no-std")]
 use alloc::{vec::Vec, boxed::Box};
 

-}
-mod sync {
-
-use alloc::str::FromStr;
-use alloc::string::String;
-use core::ffi::c_void;
-use core::convert::Infallible;
-use bitcoin::hashes::Hash;
-use crate::c_types::*;
-#[cfg(feature="no-std")]
-use alloc::{vec::Vec, boxed::Box};
-

 }
 /// 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.
 }
 /// 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.


@@ -307,7 +293,8 @@ impl Bolt11ParseError {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeBolt11ParseError) -> Self {
+       pub(crate) fn from_native(native: &Bolt11ParseErrorImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeBolt11ParseError) };

                match native {
                        nativeBolt11ParseError::Bech32Error (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                match native {
                        nativeBolt11ParseError::Bech32Error (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);


@@ -499,6 +486,9 @@ pub extern "C" fn Bolt11ParseError_skip() -> Bolt11ParseError {
 pub extern "C" fn Bolt11ParseError_eq(a: &Bolt11ParseError, b: &Bolt11ParseError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }
 pub extern "C" fn Bolt11ParseError_eq(a: &Bolt11ParseError, b: &Bolt11ParseError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }

+/// Get a string which allows debug introspection of a Bolt11ParseError object
+pub extern "C" fn Bolt11ParseError_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Bolt11ParseError }).into()}

 /// 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.
 /// 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.


@@ -550,7 +540,8 @@ impl ParseOrSemanticError {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeParseOrSemanticError) -> Self {
+       pub(crate) fn from_native(native: &ParseOrSemanticErrorImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeParseOrSemanticError) };

                match native {
                        nativeParseOrSemanticError::ParseError (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                match native {
                        nativeParseOrSemanticError::ParseError (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);


@@ -616,6 +607,9 @@ pub extern "C" fn ParseOrSemanticError_semantic_error(a: crate::lightning_invoic
 pub extern "C" fn ParseOrSemanticError_eq(a: &ParseOrSemanticError, b: &ParseOrSemanticError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }
 pub extern "C" fn ParseOrSemanticError_eq(a: &ParseOrSemanticError, b: &ParseOrSemanticError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }

+/// Get a string which allows debug introspection of a ParseOrSemanticError object
+pub extern "C" fn ParseOrSemanticError_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::ParseOrSemanticError }).into()}

 /// 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
 /// 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


@@ -630,11 +624,9 @@ pub static MAX_TIMESTAMP: u64 = lightning_invoice::MAX_TIMESTAMP;
 pub static DEFAULT_EXPIRY_TIME: u64 = lightning_invoice::DEFAULT_EXPIRY_TIME;
 /// Default minimum final CLTV expiry as defined by [BOLT 11].
 ///
 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_DELTA`].
+/// Note that this is *not* the same value as rust-lightning's minimum CLTV expiry.

 ///
 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
 ///
 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md

-/// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA

 
 #[no_mangle]
 pub static DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA: u64 = lightning_invoice::DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA;
 
 #[no_mangle]
 pub static DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA: u64 = lightning_invoice::DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA;


@@ -665,6 +657,12 @@ pub struct Bolt11Invoice {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for Bolt11Invoice {
+       type Target = nativeBolt11Invoice;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for Bolt11Invoice { }
+unsafe impl core::marker::Sync for Bolt11Invoice { }

 impl Drop for Bolt11Invoice {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeBolt11Invoice>::is_null(self.inner) {
 impl Drop for Bolt11Invoice {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeBolt11Invoice>::is_null(self.inner) {


@@ -695,6 +693,9 @@ impl Bolt11Invoice {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 /// Checks if two Bolt11Invoices contain equal inner contents.
 /// This ignores pointers and is_owned flags and looks at the values in fields.
 }
 /// Checks if two Bolt11Invoices contain equal inner contents.
 /// This ignores pointers and is_owned flags and looks at the values in fields.


@@ -705,6 +706,9 @@ pub extern "C" fn Bolt11Invoice_eq(a: &Bolt11Invoice, b: &Bolt11Invoice) -> bool
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }

+/// Get a string which allows debug introspection of a Bolt11Invoice object
+pub extern "C" fn Bolt11Invoice_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Bolt11Invoice }).into()}

 impl Clone for Bolt11Invoice {
        fn clone(&self) -> Self {
                Self {
 impl Clone for Bolt11Invoice {
        fn clone(&self) -> Self {
                Self {


@@ -758,6 +762,12 @@ pub struct SignedRawBolt11Invoice {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for SignedRawBolt11Invoice {
+       type Target = nativeSignedRawBolt11Invoice;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for SignedRawBolt11Invoice { }
+unsafe impl core::marker::Sync for SignedRawBolt11Invoice { }

 impl Drop for SignedRawBolt11Invoice {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeSignedRawBolt11Invoice>::is_null(self.inner) {
 impl Drop for SignedRawBolt11Invoice {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeSignedRawBolt11Invoice>::is_null(self.inner) {


@@ -788,6 +798,9 @@ impl SignedRawBolt11Invoice {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 /// Checks if two SignedRawBolt11Invoices contain equal inner contents.
 /// This ignores pointers and is_owned flags and looks at the values in fields.
 }
 /// Checks if two SignedRawBolt11Invoices contain equal inner contents.
 /// This ignores pointers and is_owned flags and looks at the values in fields.


@@ -798,6 +811,9 @@ pub extern "C" fn SignedRawBolt11Invoice_eq(a: &SignedRawBolt11Invoice, b: &Sign
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }

+/// Get a string which allows debug introspection of a SignedRawBolt11Invoice object
+pub extern "C" fn SignedRawBolt11Invoice_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::SignedRawBolt11Invoice }).into()}

 impl Clone for SignedRawBolt11Invoice {
        fn clone(&self) -> Self {
                Self {
 impl Clone for SignedRawBolt11Invoice {
        fn clone(&self) -> Self {
                Self {


@@ -851,6 +867,12 @@ pub struct RawBolt11Invoice {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for RawBolt11Invoice {
+       type Target = nativeRawBolt11Invoice;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for RawBolt11Invoice { }
+unsafe impl core::marker::Sync for RawBolt11Invoice { }

 impl Drop for RawBolt11Invoice {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeRawBolt11Invoice>::is_null(self.inner) {
 impl Drop for RawBolt11Invoice {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeRawBolt11Invoice>::is_null(self.inner) {


@@ -881,6 +903,9 @@ impl RawBolt11Invoice {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 /// data part
 #[no_mangle]
 }
 /// data part
 #[no_mangle]


@@ -902,6 +927,9 @@ pub extern "C" fn RawBolt11Invoice_eq(a: &RawBolt11Invoice, b: &RawBolt11Invoice
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }

+/// Get a string which allows debug introspection of a RawBolt11Invoice object
+pub extern "C" fn RawBolt11Invoice_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::RawBolt11Invoice }).into()}

 impl Clone for RawBolt11Invoice {
        fn clone(&self) -> Self {
                Self {
 impl Clone for RawBolt11Invoice {
        fn clone(&self) -> Self {
                Self {


@@ -951,6 +979,12 @@ pub struct RawDataPart {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for RawDataPart {
+       type Target = nativeRawDataPart;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for RawDataPart { }
+unsafe impl core::marker::Sync for RawDataPart { }

 impl Drop for RawDataPart {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeRawDataPart>::is_null(self.inner) {
 impl Drop for RawDataPart {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeRawDataPart>::is_null(self.inner) {


@@ -981,6 +1015,9 @@ impl RawDataPart {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 /// generation time of the invoice
 #[no_mangle]
 }
 /// generation time of the invoice
 #[no_mangle]


@@ -1002,6 +1039,9 @@ pub extern "C" fn RawDataPart_eq(a: &RawDataPart, b: &RawDataPart) -> bool {
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }

+/// Get a string which allows debug introspection of a RawDataPart object
+pub extern "C" fn RawDataPart_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::RawDataPart }).into()}

 impl Clone for RawDataPart {
        fn clone(&self) -> Self {
                Self {
 impl Clone for RawDataPart {
        fn clone(&self) -> Self {
                Self {


@@ -1056,6 +1096,12 @@ pub struct PositiveTimestamp {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for PositiveTimestamp {
+       type Target = nativePositiveTimestamp;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for PositiveTimestamp { }
+unsafe impl core::marker::Sync for PositiveTimestamp { }

 impl Drop for PositiveTimestamp {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativePositiveTimestamp>::is_null(self.inner) {
 impl Drop for PositiveTimestamp {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativePositiveTimestamp>::is_null(self.inner) {


@@ -1086,6 +1132,9 @@ impl PositiveTimestamp {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 /// Checks if two PositiveTimestamps contain equal inner contents.
 /// This ignores pointers and is_owned flags and looks at the values in fields.
 }
 /// Checks if two PositiveTimestamps contain equal inner contents.
 /// This ignores pointers and is_owned flags and looks at the values in fields.


@@ -1096,6 +1145,9 @@ pub extern "C" fn PositiveTimestamp_eq(a: &PositiveTimestamp, b: &PositiveTimest
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }
        if a.inner.is_null() || b.inner.is_null() { return false; }
        if a.get_native_ref() == b.get_native_ref() { true } else { false }
 }

+/// Get a string which allows debug introspection of a PositiveTimestamp object
+pub extern "C" fn PositiveTimestamp_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::PositiveTimestamp }).into()}

 impl Clone for PositiveTimestamp {
        fn clone(&self) -> Self {
                Self {
 impl Clone for PositiveTimestamp {
        fn clone(&self) -> Self {
                Self {


@@ -1162,7 +1214,8 @@ impl SiPrefix {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeSiPrefix) -> Self {
+       pub(crate) fn from_native(native: &SiPrefixImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeSiPrefix) };

                match native {
                        nativeSiPrefix::Milli => SiPrefix::Milli,
                        nativeSiPrefix::Micro => SiPrefix::Micro,
                match native {
                        nativeSiPrefix::Milli => SiPrefix::Milli,
                        nativeSiPrefix::Micro => SiPrefix::Micro,


@@ -1217,6 +1270,9 @@ 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 }
 }
 pub extern "C" fn SiPrefix_eq(a: &SiPrefix, b: &SiPrefix) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }

+/// Get a string which allows debug introspection of a SiPrefix object
+pub extern "C" fn SiPrefix_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::SiPrefix }).into()}

 /// Generates a non-cryptographic 64-bit hash of the SiPrefix.
 #[no_mangle]
 pub extern "C" fn SiPrefix_hash(o: &SiPrefix) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the SiPrefix.
 #[no_mangle]
 pub extern "C" fn SiPrefix_hash(o: &SiPrefix) -> u64 {


@@ -1276,7 +1332,8 @@ impl Currency {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeCurrency) -> Self {
+       pub(crate) fn from_native(native: &CurrencyImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeCurrency) };

                match native {
                        nativeCurrency::Bitcoin => Currency::Bitcoin,
                        nativeCurrency::BitcoinTestnet => Currency::BitcoinTestnet,
                match native {
                        nativeCurrency::Bitcoin => Currency::Bitcoin,
                        nativeCurrency::BitcoinTestnet => Currency::BitcoinTestnet,


@@ -1331,6 +1388,9 @@ 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}
 /// Utility method to constructs a new Signet-variant Currency
 pub extern "C" fn Currency_signet() -> Currency {
        Currency::Signet}

+/// Get a string which allows debug introspection of a Currency object
+pub extern "C" fn Currency_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Currency }).into()}

 /// Generates a non-cryptographic 64-bit hash of the Currency.
 #[no_mangle]
 pub extern "C" fn Currency_hash(o: &Currency) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the Currency.
 #[no_mangle]
 pub extern "C" fn Currency_hash(o: &Currency) -> u64 {


@@ -1366,6 +1426,12 @@ pub struct Sha256 {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for Sha256 {
+       type Target = nativeSha256;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for Sha256 { }
+unsafe impl core::marker::Sync for Sha256 { }

 impl Drop for Sha256 {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeSha256>::is_null(self.inner) {
 impl Drop for Sha256 {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeSha256>::is_null(self.inner) {


@@ -1396,6 +1462,9 @@ impl Sha256 {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 impl Clone for Sha256 {
        fn clone(&self) -> Self {
 }
 impl Clone for Sha256 {
        fn clone(&self) -> Self {


@@ -1416,6 +1485,9 @@ 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()
 }
 pub extern "C" fn Sha256_clone(orig: &Sha256) -> Sha256 {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a Sha256 object
+pub extern "C" fn Sha256_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Sha256 }).into()}

 /// Generates a non-cryptographic 64-bit hash of the Sha256.
 #[no_mangle]
 pub extern "C" fn Sha256_hash(o: &Sha256) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the Sha256.
 #[no_mangle]
 pub extern "C" fn Sha256_hash(o: &Sha256) -> u64 {


@@ -1467,6 +1539,12 @@ pub struct Description {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for Description {
+       type Target = nativeDescription;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for Description { }
+unsafe impl core::marker::Sync for Description { }

 impl Drop for Description {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeDescription>::is_null(self.inner) {
 impl Drop for Description {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeDescription>::is_null(self.inner) {


@@ -1497,6 +1575,9 @@ impl Description {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 impl Clone for Description {
        fn clone(&self) -> Self {
 }
 impl Clone for Description {
        fn clone(&self) -> Self {


@@ -1517,6 +1598,9 @@ 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()
 }
 pub extern "C" fn Description_clone(orig: &Description) -> Description {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a Description object
+pub extern "C" fn Description_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Description }).into()}

 /// Generates a non-cryptographic 64-bit hash of the Description.
 #[no_mangle]
 pub extern "C" fn Description_hash(o: &Description) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the Description.
 #[no_mangle]
 pub extern "C" fn Description_hash(o: &Description) -> u64 {


@@ -1556,6 +1640,12 @@ pub struct PayeePubKey {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for PayeePubKey {
+       type Target = nativePayeePubKey;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for PayeePubKey { }
+unsafe impl core::marker::Sync for PayeePubKey { }

 impl Drop for PayeePubKey {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativePayeePubKey>::is_null(self.inner) {
 impl Drop for PayeePubKey {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativePayeePubKey>::is_null(self.inner) {


@@ -1586,6 +1676,9 @@ impl PayeePubKey {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 #[no_mangle]
 pub extern "C" fn PayeePubKey_get_a(this_ptr: &PayeePubKey) -> crate::c_types::PublicKey {
 }
 #[no_mangle]
 pub extern "C" fn PayeePubKey_get_a(this_ptr: &PayeePubKey) -> crate::c_types::PublicKey {


@@ -1623,6 +1716,9 @@ 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()
 }
 pub extern "C" fn PayeePubKey_clone(orig: &PayeePubKey) -> PayeePubKey {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a PayeePubKey object
+pub extern "C" fn PayeePubKey_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::PayeePubKey }).into()}

 /// Generates a non-cryptographic 64-bit hash of the PayeePubKey.
 #[no_mangle]
 pub extern "C" fn PayeePubKey_hash(o: &PayeePubKey) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the PayeePubKey.
 #[no_mangle]
 pub extern "C" fn PayeePubKey_hash(o: &PayeePubKey) -> u64 {


@@ -1663,6 +1759,12 @@ pub struct ExpiryTime {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for ExpiryTime {
+       type Target = nativeExpiryTime;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for ExpiryTime { }
+unsafe impl core::marker::Sync for ExpiryTime { }

 impl Drop for ExpiryTime {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeExpiryTime>::is_null(self.inner) {
 impl Drop for ExpiryTime {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeExpiryTime>::is_null(self.inner) {


@@ -1693,6 +1795,9 @@ impl ExpiryTime {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 impl Clone for ExpiryTime {
        fn clone(&self) -> Self {
 }
 impl Clone for ExpiryTime {
        fn clone(&self) -> Self {


@@ -1713,6 +1818,9 @@ 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()
 }
 pub extern "C" fn ExpiryTime_clone(orig: &ExpiryTime) -> ExpiryTime {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a ExpiryTime object
+pub extern "C" fn ExpiryTime_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::ExpiryTime }).into()}

 /// Generates a non-cryptographic 64-bit hash of the ExpiryTime.
 #[no_mangle]
 pub extern "C" fn ExpiryTime_hash(o: &ExpiryTime) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the ExpiryTime.
 #[no_mangle]
 pub extern "C" fn ExpiryTime_hash(o: &ExpiryTime) -> u64 {


@@ -1752,6 +1860,12 @@ pub struct MinFinalCltvExpiryDelta {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for MinFinalCltvExpiryDelta {
+       type Target = nativeMinFinalCltvExpiryDelta;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for MinFinalCltvExpiryDelta { }
+unsafe impl core::marker::Sync for MinFinalCltvExpiryDelta { }

 impl Drop for MinFinalCltvExpiryDelta {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeMinFinalCltvExpiryDelta>::is_null(self.inner) {
 impl Drop for MinFinalCltvExpiryDelta {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeMinFinalCltvExpiryDelta>::is_null(self.inner) {


@@ -1782,6 +1896,9 @@ impl MinFinalCltvExpiryDelta {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 #[no_mangle]
 pub extern "C" fn MinFinalCltvExpiryDelta_get_a(this_ptr: &MinFinalCltvExpiryDelta) -> u64 {
 }
 #[no_mangle]
 pub extern "C" fn MinFinalCltvExpiryDelta_get_a(this_ptr: &MinFinalCltvExpiryDelta) -> u64 {


@@ -1819,6 +1936,9 @@ pub(crate) extern "C" fn MinFinalCltvExpiryDelta_clone_void(this_ptr: *const c_v
 pub extern "C" fn MinFinalCltvExpiryDelta_clone(orig: &MinFinalCltvExpiryDelta) -> MinFinalCltvExpiryDelta {
        orig.clone()
 }
 pub extern "C" fn MinFinalCltvExpiryDelta_clone(orig: &MinFinalCltvExpiryDelta) -> MinFinalCltvExpiryDelta {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a MinFinalCltvExpiryDelta object
+pub extern "C" fn MinFinalCltvExpiryDelta_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::MinFinalCltvExpiryDelta }).into()}

 /// Generates a non-cryptographic 64-bit hash of the MinFinalCltvExpiryDelta.
 #[no_mangle]
 pub extern "C" fn MinFinalCltvExpiryDelta_hash(o: &MinFinalCltvExpiryDelta) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the MinFinalCltvExpiryDelta.
 #[no_mangle]
 pub extern "C" fn MinFinalCltvExpiryDelta_hash(o: &MinFinalCltvExpiryDelta) -> u64 {


@@ -1871,13 +1991,13 @@ impl Fallback {
                        Fallback::PubKeyHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                nativeFallback::PubKeyHash (
                        Fallback::PubKeyHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                nativeFallback::PubKeyHash (

-                                       bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(a_nonref.data)),
+                                       bitcoin::PubkeyHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a_nonref.data)),

                                )
                        },
                        Fallback::ScriptHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                nativeFallback::ScriptHash (
                                )
                        },
                        Fallback::ScriptHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                nativeFallback::ScriptHash (

-                                       bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(a_nonref.data)),
+                                       bitcoin::ScriptHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a_nonref.data)),

                                )
                        },
                }
                                )
                        },
                }


@@ -1894,18 +2014,19 @@ impl Fallback {
                        },
                        Fallback::PubKeyHash (mut a, ) => {
                                nativeFallback::PubKeyHash (
                        },
                        Fallback::PubKeyHash (mut a, ) => {
                                nativeFallback::PubKeyHash (

-                                       bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(a.data)),
+                                       bitcoin::PubkeyHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a.data)),

                                )
                        },
                        Fallback::ScriptHash (mut a, ) => {
                                nativeFallback::ScriptHash (
                                )
                        },
                        Fallback::ScriptHash (mut a, ) => {
                                nativeFallback::ScriptHash (

-                                       bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(a.data)),
+                                       bitcoin::ScriptHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a.data)),

                                )
                        },
                }
        }
        #[allow(unused)]
                                )
                        },
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeFallback) -> Self {
+       pub(crate) fn from_native(native: &FallbackImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeFallback) };

                match native {
                        nativeFallback::SegWitProgram {ref version, ref program, } => {
                                let mut version_nonref = Clone::clone(version);
                match native {
                        nativeFallback::SegWitProgram {ref version, ref program, } => {
                                let mut version_nonref = Clone::clone(version);


@@ -1919,13 +2040,13 @@ impl Fallback {
                        nativeFallback::PubKeyHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                Fallback::PubKeyHash (
                        nativeFallback::PubKeyHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                Fallback::PubKeyHash (

-                                       crate::c_types::TwentyBytes { data: a_nonref.as_hash().into_inner() },
+                                       crate::c_types::TwentyBytes { data: *a_nonref.as_ref() },

                                )
                        },
                        nativeFallback::ScriptHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                Fallback::ScriptHash (
                                )
                        },
                        nativeFallback::ScriptHash (ref a, ) => {
                                let mut a_nonref = Clone::clone(a);
                                Fallback::ScriptHash (

-                                       crate::c_types::TwentyBytes { data: a_nonref.as_hash().into_inner() },
+                                       crate::c_types::TwentyBytes { data: *a_nonref.as_ref() },

                                )
                        },
                }
                                )
                        },
                }


@@ -1942,12 +2063,12 @@ impl Fallback {
                        },
                        nativeFallback::PubKeyHash (mut a, ) => {
                                Fallback::PubKeyHash (
                        },
                        nativeFallback::PubKeyHash (mut a, ) => {
                                Fallback::PubKeyHash (

-                                       crate::c_types::TwentyBytes { data: a.as_hash().into_inner() },
+                                       crate::c_types::TwentyBytes { data: *a.as_ref() },

                                )
                        },
                        nativeFallback::ScriptHash (mut a, ) => {
                                Fallback::ScriptHash (
                                )
                        },
                        nativeFallback::ScriptHash (mut a, ) => {
                                Fallback::ScriptHash (

-                                       crate::c_types::TwentyBytes { data: a.as_hash().into_inner() },
+                                       crate::c_types::TwentyBytes { data: *a.as_ref() },

                                )
                        },
                }
                                )
                        },
                }


@@ -1989,6 +2110,9 @@ 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, )
 }
 pub extern "C" fn Fallback_script_hash(a: crate::c_types::TwentyBytes) -> Fallback {
        Fallback::ScriptHash(a, )
 }

+/// Get a string which allows debug introspection of a Fallback object
+pub extern "C" fn Fallback_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Fallback }).into()}

 /// Generates a non-cryptographic 64-bit hash of the Fallback.
 #[no_mangle]
 pub extern "C" fn Fallback_hash(o: &Fallback) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the Fallback.
 #[no_mangle]
 pub extern "C" fn Fallback_hash(o: &Fallback) -> u64 {


@@ -2024,6 +2148,12 @@ pub struct Bolt11InvoiceSignature {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for Bolt11InvoiceSignature {
+       type Target = nativeBolt11InvoiceSignature;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for Bolt11InvoiceSignature { }
+unsafe impl core::marker::Sync for Bolt11InvoiceSignature { }

 impl Drop for Bolt11InvoiceSignature {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeBolt11InvoiceSignature>::is_null(self.inner) {
 impl Drop for Bolt11InvoiceSignature {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativeBolt11InvoiceSignature>::is_null(self.inner) {


@@ -2054,6 +2184,26 @@ impl Bolt11InvoiceSignature {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }
+}
+#[no_mangle]
+pub extern "C" fn Bolt11InvoiceSignature_get_a(this_ptr: &Bolt11InvoiceSignature) -> crate::c_types::RecoverableSignature {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().0;
+       crate::c_types::RecoverableSignature::from_rust(&inner_val)
+}
+#[no_mangle]
+pub extern "C" fn Bolt11InvoiceSignature_set_a(this_ptr: &mut Bolt11InvoiceSignature, mut val: crate::c_types::RecoverableSignature) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.0 = val.into_rust();
+}
+/// Constructs a new Bolt11InvoiceSignature given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn Bolt11InvoiceSignature_new(mut a_arg: crate::c_types::RecoverableSignature) -> Bolt11InvoiceSignature {
+       Bolt11InvoiceSignature { inner: ObjOps::heap_alloc(lightning_invoice::Bolt11InvoiceSignature (
+               a_arg.into_rust(),
+       )), is_owned: true }

 }
 impl Clone for Bolt11InvoiceSignature {
        fn clone(&self) -> Self {
 }
 impl Clone for Bolt11InvoiceSignature {
        fn clone(&self) -> Self {


@@ -2074,6 +2224,9 @@ pub(crate) extern "C" fn Bolt11InvoiceSignature_clone_void(this_ptr: *const c_vo
 pub extern "C" fn Bolt11InvoiceSignature_clone(orig: &Bolt11InvoiceSignature) -> Bolt11InvoiceSignature {
        orig.clone()
 }
 pub extern "C" fn Bolt11InvoiceSignature_clone(orig: &Bolt11InvoiceSignature) -> Bolt11InvoiceSignature {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a Bolt11InvoiceSignature object
+pub extern "C" fn Bolt11InvoiceSignature_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Bolt11InvoiceSignature }).into()}

 /// Generates a non-cryptographic 64-bit hash of the Bolt11InvoiceSignature.
 #[no_mangle]
 pub extern "C" fn Bolt11InvoiceSignature_hash(o: &Bolt11InvoiceSignature) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the Bolt11InvoiceSignature.
 #[no_mangle]
 pub extern "C" fn Bolt11InvoiceSignature_hash(o: &Bolt11InvoiceSignature) -> u64 {


@@ -2117,6 +2270,12 @@ pub struct PrivateRoute {
        pub is_owned: bool,
 }
 
        pub is_owned: bool,
 }
 

+impl core::ops::Deref for PrivateRoute {
+       type Target = nativePrivateRoute;
+       fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for PrivateRoute { }
+unsafe impl core::marker::Sync for PrivateRoute { }

 impl Drop for PrivateRoute {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativePrivateRoute>::is_null(self.inner) {
 impl Drop for PrivateRoute {
        fn drop(&mut self) {
                if self.is_owned && !<*mut nativePrivateRoute>::is_null(self.inner) {


@@ -2147,6 +2306,9 @@ impl PrivateRoute {
                self.inner = core::ptr::null_mut();
                ret
        }
                self.inner = core::ptr::null_mut();
                ret
        }

+       pub(crate) fn as_ref_to(&self) -> Self {
+               Self { inner: self.inner, is_owned: false }
+       }

 }
 impl Clone for PrivateRoute {
        fn clone(&self) -> Self {
 }
 impl Clone for PrivateRoute {
        fn clone(&self) -> Self {


@@ -2167,6 +2329,9 @@ 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()
 }
 pub extern "C" fn PrivateRoute_clone(orig: &PrivateRoute) -> PrivateRoute {
        orig.clone()
 }

+/// Get a string which allows debug introspection of a PrivateRoute object
+pub extern "C" fn PrivateRoute_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::PrivateRoute }).into()}

 /// Generates a non-cryptographic 64-bit hash of the PrivateRoute.
 #[no_mangle]
 pub extern "C" fn PrivateRoute_hash(o: &PrivateRoute) -> u64 {
 /// Generates a non-cryptographic 64-bit hash of the PrivateRoute.
 #[no_mangle]
 pub extern "C" fn PrivateRoute_hash(o: &PrivateRoute) -> u64 {


@@ -2328,9 +2493,9 @@ pub extern "C" fn RawBolt11Invoice_payment_metadata(this_arg: &crate::lightning_
 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 #[must_use]
 #[no_mangle]
 /// 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 RawBolt11Invoice_features(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::lightning::ln::features::Bolt11InvoiceFeatures {
+pub extern "C" fn RawBolt11Invoice_features(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::lightning_types::features::Bolt11InvoiceFeatures {

        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.features();
        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.features();

-       let mut local_ret = crate::lightning::ln::features::Bolt11InvoiceFeatures { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning::ln::features::Bolt11InvoiceFeatures<>) as *mut _ }, is_owned: false };
+       let mut local_ret = crate::lightning_types::features::Bolt11InvoiceFeatures { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_types::features::Bolt11InvoiceFeatures<>) as *mut _ }, is_owned: false };

        local_ret
 }
 
        local_ret
 }
 


@@ -2342,6 +2507,7 @@ pub extern "C" fn RawBolt11Invoice_private_routes(this_arg: &crate::lightning_in
        local_ret.into()
 }
 
        local_ret.into()
 }
 

+/// Returns `None` if no amount is set or on overflow.

 #[must_use]
 #[no_mangle]
 pub extern "C" fn RawBolt11Invoice_amount_pico_btc(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::c_types::derived::COption_u64Z {
 #[must_use]
 #[no_mangle]
 pub extern "C" fn RawBolt11Invoice_amount_pico_btc(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::c_types::derived::COption_u64Z {


@@ -2494,7 +2660,7 @@ pub extern "C" fn Bolt11Invoice_duration_since_epoch(this_arg: &crate::lightning
 #[no_mangle]
 pub extern "C" fn Bolt11Invoice_payment_hash(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> *const [u8; 32] {
        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_hash();
 #[no_mangle]
 pub extern "C" fn Bolt11Invoice_payment_hash(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> *const [u8; 32] {
        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_hash();

-       ret.as_inner()
+       ret.as_ref()

 }
 
 /// Get the payee's public key if one was included in the invoice
 }
 
 /// Get the payee's public key if one was included in the invoice


@@ -2530,9 +2696,9 @@ pub extern "C" fn Bolt11Invoice_payment_metadata(this_arg: &crate::lightning_inv
 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 #[must_use]
 #[no_mangle]
 /// 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 Bolt11Invoice_features(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::lightning::ln::features::Bolt11InvoiceFeatures {
+pub extern "C" fn Bolt11Invoice_features(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::lightning_types::features::Bolt11InvoiceFeatures {

        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.features();
        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.features();

-       let mut local_ret = crate::lightning::ln::features::Bolt11InvoiceFeatures { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning::ln::features::Bolt11InvoiceFeatures<>) as *mut _ }, is_owned: false };
+       let mut local_ret = crate::lightning_types::features::Bolt11InvoiceFeatures { inner: unsafe { (if ret.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (ret.unwrap()) }) } as *const lightning_types::features::Bolt11InvoiceFeatures<>) as *mut _ }, is_owned: false };

        local_ret
 }
 
        local_ret
 }
 


@@ -2544,6 +2710,15 @@ pub extern "C" fn Bolt11Invoice_recover_payee_pub_key(this_arg: &crate::lightnin
        crate::c_types::PublicKey::from_rust(&ret)
 }
 
        crate::c_types::PublicKey::from_rust(&ret)
 }
 

+/// Recover the payee's public key if one was included in the invoice, otherwise return the
+/// recovered public key from the signature
+#[must_use]
+#[no_mangle]
+pub extern "C" fn Bolt11Invoice_get_payee_pub_key(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::PublicKey {
+       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.get_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]
 /// Returns the Duration since the Unix epoch at which the invoice expires.
 /// Returning None if overflow occurred.
 #[must_use]


@@ -2628,7 +2803,7 @@ pub extern "C" fn Bolt11Invoice_private_routes(this_arg: &crate::lightning_invoi
 #[no_mangle]
 pub extern "C" fn Bolt11Invoice_route_hints(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::derived::CVec_RouteHintZ {
        let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.route_hints();
 #[no_mangle]
 pub extern "C" fn Bolt11Invoice_route_hints(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> 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 } }); };
+       let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { crate::lightning_types::routing::RouteHint { inner: ObjOps::heap_alloc(item), is_owned: true } }); };

        local_ret.into()
 }
 
        local_ret.into()
 }
 


@@ -2649,8 +2824,8 @@ pub extern "C" fn Bolt11Invoice_amount_milli_satoshis(this_arg: &crate::lightnin
        local_ret
 }
 
        local_ret
 }
 

-/// Creates a new `Description` if `description` is at most 1023 __bytes__ long,
-/// returns [`CreationError::DescriptionTooLong`] otherwise
+/// Creates a new `Description` if `description` is at most 1023 * 5 bits (i.e., 639 bytes)
+/// long, and returns [`CreationError::DescriptionTooLong`] otherwise.

 ///
 /// Please note that single characters may use more than one byte due to UTF8 encoding.
 #[must_use]
 ///
 /// Please note that single characters may use more than one byte due to UTF8 encoding.
 #[must_use]


@@ -2661,14 +2836,27 @@ pub extern "C" fn Description_new(mut description: crate::c_types::Str) -> crate
        local_ret
 }
 
        local_ret
 }
 

-/// Returns the underlying description [`String`]
+/// Returns the underlying description [`UntrustedString`]

 #[must_use]
 #[no_mangle]
 #[must_use]
 #[no_mangle]

-pub extern "C" fn Description_into_inner(mut this_arg: crate::lightning_invoice::Description) -> crate::c_types::Str {
+pub extern "C" fn Description_into_inner(mut this_arg: crate::lightning_invoice::Description) -> crate::lightning_types::string::UntrustedString {

        let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_inner();
        let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_inner();

-       ret.into()
+       crate::lightning_types::string::UntrustedString { inner: ObjOps::heap_alloc(ret), is_owned: true }

 }
 
 }
 

+/// Get a reference to the underlying description [`UntrustedString`]
+#[must_use]
+#[no_mangle]
+pub extern "C" fn Description_as_inner(this_arg: &crate::lightning_invoice::Description) -> crate::lightning_types::string::UntrustedString {
+       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.as_inner();
+       crate::lightning_types::string::UntrustedString { inner: unsafe { ObjOps::nonnull_ptr_to_inner((ret as *const lightning_types::string::UntrustedString<>) as *mut _) }, is_owned: false }
+}
+
+#[no_mangle]
+/// Get the string representation of a Description object
+pub extern "C" fn Description_to_str(o: &crate::lightning_invoice::Description) -> Str {
+       alloc::format!("{}", o.get_native_ref()).into()
+}

 /// Construct an `ExpiryTime` from seconds.
 #[must_use]
 #[no_mangle]
 /// Construct an `ExpiryTime` from seconds.
 #[must_use]
 #[no_mangle]


@@ -2704,7 +2892,7 @@ pub extern "C" fn ExpiryTime_as_duration(this_arg: &crate::lightning_invoice::Ex
 /// Creates a new (partial) route from a list of hops
 #[must_use]
 #[no_mangle]
 /// Creates a new (partial) route from a list of hops
 #[must_use]
 #[no_mangle]

-pub extern "C" fn PrivateRoute_new(mut hops: crate::lightning::routing::router::RouteHint) -> crate::c_types::derived::CResult_PrivateRouteCreationErrorZ {
+pub extern "C" fn PrivateRoute_new(mut hops: crate::lightning_types::routing::RouteHint) -> crate::c_types::derived::CResult_PrivateRouteCreationErrorZ {

        let mut ret = lightning_invoice::PrivateRoute::new(*unsafe { Box::from_raw(hops.take_inner()) });
        let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::PrivateRoute { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::CreationError::native_into(e) }).into() };
        local_ret
        let mut ret = lightning_invoice::PrivateRoute::new(*unsafe { Box::from_raw(hops.take_inner()) });
        let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::PrivateRoute { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::CreationError::native_into(e) }).into() };
        local_ret


@@ -2713,9 +2901,9 @@ pub extern "C" fn PrivateRoute_new(mut hops: crate::lightning::routing::router::
 /// Returns the underlying list of hops
 #[must_use]
 #[no_mangle]
 /// Returns the underlying list of hops
 #[must_use]
 #[no_mangle]

-pub extern "C" fn PrivateRoute_into_inner(mut this_arg: crate::lightning_invoice::PrivateRoute) -> crate::lightning::routing::router::RouteHint {
+pub extern "C" fn PrivateRoute_into_inner(mut this_arg: crate::lightning_invoice::PrivateRoute) -> crate::lightning_types::routing::RouteHint {

        let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_inner();
        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 }
+       crate::lightning_types::routing::RouteHint { inner: ObjOps::heap_alloc(ret), is_owned: true }

 }
 
 /// Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
 }
 
 /// Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]


@@ -2731,14 +2919,9 @@ pub enum CreationError {
        TimestampOutOfBounds,
        /// The supplied millisatoshi amount was greater than the total bitcoin supply.
        InvalidAmount,
        TimestampOutOfBounds,
        /// The supplied millisatoshi amount was greater than the total bitcoin supply.
        InvalidAmount,

-       /// Route hints were required for this invoice and were missing. Applies to
-       /// [phantom invoices].
-       ///
-       /// [phantom invoices]: crate::utils::create_phantom_invoice
+       /// Route hints were required for this invoice and were missing.

        MissingRouteHints,
        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
+       /// The provided `min_final_cltv_expiry_delta` was less than rust-lightning's minimum.

        MinFinalCltvExpiryDeltaTooShort,
 }
 use lightning_invoice::CreationError as CreationErrorImport;
        MinFinalCltvExpiryDeltaTooShort,
 }
 use lightning_invoice::CreationError as CreationErrorImport;


@@ -2768,7 +2951,8 @@ impl CreationError {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeCreationError) -> Self {
+       pub(crate) fn from_native(native: &CreationErrorImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeCreationError) };

                match native {
                        nativeCreationError::DescriptionTooLong => CreationError::DescriptionTooLong,
                        nativeCreationError::RouteTooLong => CreationError::RouteTooLong,
                match native {
                        nativeCreationError::DescriptionTooLong => CreationError::DescriptionTooLong,
                        nativeCreationError::RouteTooLong => CreationError::RouteTooLong,


@@ -2835,6 +3019,9 @@ pub extern "C" fn CreationError_min_final_cltv_expiry_delta_too_short() -> Creat
 pub extern "C" fn CreationError_eq(a: &CreationError, b: &CreationError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }
 pub extern "C" fn CreationError_eq(a: &CreationError, b: &CreationError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }

+/// Get a string which allows debug introspection of a CreationError object
+pub extern "C" fn CreationError_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::CreationError }).into()}

 #[no_mangle]
 /// Get the string representation of a CreationError object
 pub extern "C" fn CreationError_to_str(o: &crate::lightning_invoice::CreationError) -> Str {
 #[no_mangle]
 /// Get the string representation of a CreationError object
 pub extern "C" fn CreationError_to_str(o: &crate::lightning_invoice::CreationError) -> Str {


@@ -2903,7 +3090,8 @@ impl Bolt11SemanticError {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeBolt11SemanticError) -> Self {
+       pub(crate) fn from_native(native: &Bolt11SemanticErrorImport) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeBolt11SemanticError) };

                match native {
                        nativeBolt11SemanticError::NoPaymentHash => Bolt11SemanticError::NoPaymentHash,
                        nativeBolt11SemanticError::MultiplePaymentHashes => Bolt11SemanticError::MultiplePaymentHashes,
                match native {
                        nativeBolt11SemanticError::NoPaymentHash => Bolt11SemanticError::NoPaymentHash,
                        nativeBolt11SemanticError::MultiplePaymentHashes => Bolt11SemanticError::MultiplePaymentHashes,


@@ -2994,6 +3182,9 @@ pub extern "C" fn Bolt11SemanticError_imprecise_amount() -> Bolt11SemanticError
 pub extern "C" fn Bolt11SemanticError_eq(a: &Bolt11SemanticError, b: &Bolt11SemanticError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }
 pub extern "C" fn Bolt11SemanticError_eq(a: &Bolt11SemanticError, b: &Bolt11SemanticError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }

+/// Get a string which allows debug introspection of a Bolt11SemanticError object
+pub extern "C" fn Bolt11SemanticError_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::Bolt11SemanticError }).into()}

 #[no_mangle]
 /// Get the string representation of a Bolt11SemanticError object
 pub extern "C" fn Bolt11SemanticError_to_str(o: &crate::lightning_invoice::Bolt11SemanticError) -> Str {
 #[no_mangle]
 /// Get the string representation of a Bolt11SemanticError object
 pub extern "C" fn Bolt11SemanticError_to_str(o: &crate::lightning_invoice::Bolt11SemanticError) -> Str {


@@ -3047,7 +3238,8 @@ impl SignOrCreationError {
                }
        }
        #[allow(unused)]
                }
        }
        #[allow(unused)]

-       pub(crate) fn from_native(native: &nativeSignOrCreationError) -> Self {
+       pub(crate) fn from_native(native: &SignOrCreationErrorImport<>) -> Self {
+               let native = unsafe { &*(native as *const _ as *const c_void as *const nativeSignOrCreationError) };

                match native {
                        nativeSignOrCreationError::SignError (ref a, ) => {
                                SignOrCreationError::SignError                  },
                match native {
                        nativeSignOrCreationError::SignError (ref a, ) => {
                                SignOrCreationError::SignError                  },


@@ -3106,6 +3298,9 @@ pub extern "C" fn SignOrCreationError_creation_error(a: crate::lightning_invoice
 pub extern "C" fn SignOrCreationError_eq(a: &SignOrCreationError, b: &SignOrCreationError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }
 pub extern "C" fn SignOrCreationError_eq(a: &SignOrCreationError, b: &SignOrCreationError) -> bool {
        if &a.to_native() == &b.to_native() { true } else { false }
 }

+/// Get a string which allows debug introspection of a SignOrCreationError object
+pub extern "C" fn SignOrCreationError_debug_str_void(o: *const c_void) -> Str {
+       alloc::format!("{:?}", unsafe { o as *const crate::lightning_invoice::SignOrCreationError }).into()}

 #[no_mangle]
 /// Get the string representation of a SignOrCreationError object
 pub extern "C" fn SignOrCreationError_to_str(o: &crate::lightning_invoice::SignOrCreationError) -> Str {
 #[no_mangle]
 /// Get the string representation of a SignOrCreationError object
 pub extern "C" fn SignOrCreationError_to_str(o: &crate::lightning_invoice::SignOrCreationError) -> Str {