X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning_invoice%2Fmod.rs;h=4c8a964949725b44729296cd9aa44a9b3c905420;hb=HEAD;hp=6fb6248fc02b631a75d2f7b859a5c09becf978c3;hpb=27a0520e39d348f9949016d4d1219c34d8450da6;p=ldk-c-bindings diff --git a/lightning-c-bindings/src/lightning_invoice/mod.rs b/lightning-c-bindings/src/lightning_invoice/mod.rs index 6fb6248..2a4da12 100644 --- a/lightning-c-bindings/src/lightning_invoice/mod.rs +++ b/lightning-c-bindings/src/lightning_invoice/mod.rs @@ -11,13 +11,14 @@ //! invoices and functions to create, encode and decode these. If you just want to use the standard //! en-/decoding functionality this should get you started: //! -//! * For parsing use `str::parse::(&self)` (see [`Invoice::from_str`]) +//! * For parsing use `str::parse::(&self)` (see [`Bolt11Invoice::from_str`]) //! * For constructing invoices use the [`InvoiceBuilder`] //! * For serializing invoices use the [`Display`]/[`ToString`] traits //! -//! [`Invoice::from_str`]: crate::Invoice#impl-FromStr +//! [`Bolt11Invoice::from_str`]: crate::Bolt11Invoice#impl-FromStr use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -28,20 +29,10 @@ 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; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -52,6 +43,7 @@ use alloc::{vec::Vec, boxed::Box}; mod hrp_sm { use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -62,7 +54,7 @@ use alloc::{vec::Vec, boxed::Box}; } #[no_mangle] /// Read a SiPrefix object from a string -pub extern "C" fn SiPrefix_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SiPrefixParseErrorZ { +pub extern "C" fn SiPrefix_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SiPrefixBolt11ParseErrorZ { match lightning_invoice::SiPrefix::from_str(s.into_str()) { Ok(r) => { crate::c_types::CResultTempl::ok( @@ -71,18 +63,18 @@ pub extern "C" fn SiPrefix_from_str(s: crate::c_types::Str) -> crate::c_types::d }, Err(e) => { crate::c_types::CResultTempl::err( - crate::lightning_invoice::ParseError::native_into(e) + crate::lightning_invoice::Bolt11ParseError::native_into(e) ) }, }.into() } #[no_mangle] -/// Read a Invoice object from a string -pub extern "C" fn Invoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_InvoiceParseOrSemanticErrorZ { - match lightning_invoice::Invoice::from_str(s.into_str()) { +/// Read a Bolt11Invoice object from a string +pub extern "C" fn Bolt11Invoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_Bolt11InvoiceParseOrSemanticErrorZ { + match lightning_invoice::Bolt11Invoice::from_str(s.into_str()) { Ok(r) => { crate::c_types::CResultTempl::ok( - crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(r), is_owned: true } + crate::lightning_invoice::Bolt11Invoice { inner: ObjOps::heap_alloc(r), is_owned: true } ) }, Err(e) => { @@ -93,24 +85,24 @@ pub extern "C" fn Invoice_from_str(s: crate::c_types::Str) -> crate::c_types::de }.into() } #[no_mangle] -/// Read a SignedRawInvoice object from a string -pub extern "C" fn SignedRawInvoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SignedRawInvoiceParseErrorZ { - match lightning_invoice::SignedRawInvoice::from_str(s.into_str()) { +/// Read a SignedRawBolt11Invoice object from a string +pub extern "C" fn SignedRawBolt11Invoice_from_str(s: crate::c_types::Str) -> crate::c_types::derived::CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ { + match lightning_invoice::SignedRawBolt11Invoice::from_str(s.into_str()) { Ok(r) => { crate::c_types::CResultTempl::ok( - crate::lightning_invoice::SignedRawInvoice { inner: ObjOps::heap_alloc(r), is_owned: true } + crate::lightning_invoice::SignedRawBolt11Invoice { inner: ObjOps::heap_alloc(r), is_owned: true } ) }, Err(e) => { crate::c_types::CResultTempl::err( - crate::lightning_invoice::ParseError::native_into(e) + crate::lightning_invoice::Bolt11ParseError::native_into(e) ) }, }.into() } #[no_mangle] -/// Get the string representation of a ParseError object -pub extern "C" fn ParseError_to_str(o: &crate::lightning_invoice::ParseError) -> Str { +/// Get the string representation of a Bolt11ParseError object +pub extern "C" fn Bolt11ParseError_to_str(o: &crate::lightning_invoice::Bolt11ParseError) -> Str { alloc::format!("{}", &o.to_native()).into() } #[no_mangle] @@ -122,6 +114,7 @@ pub extern "C" fn ParseOrSemanticError_to_str(o: &crate::lightning_invoice::Pars mod ser { use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -130,13 +123,13 @@ use crate::c_types::*; use alloc::{vec::Vec, boxed::Box}; #[no_mangle] -/// Get the string representation of a Invoice object -pub extern "C" fn Invoice_to_str(o: &crate::lightning_invoice::Invoice) -> Str { +/// Get the string representation of a Bolt11Invoice object +pub extern "C" fn Bolt11Invoice_to_str(o: &crate::lightning_invoice::Bolt11Invoice) -> Str { alloc::format!("{}", o.get_native_ref()).into() } #[no_mangle] -/// Get the string representation of a SignedRawInvoice object -pub extern "C" fn SignedRawInvoice_to_str(o: &crate::lightning_invoice::SignedRawInvoice) -> Str { +/// Get the string representation of a SignedRawBolt11Invoice object +pub extern "C" fn SignedRawBolt11Invoice_to_str(o: &crate::lightning_invoice::SignedRawBolt11Invoice) -> Str { alloc::format!("{}", o.get_native_ref()).into() } #[no_mangle] @@ -153,6 +146,7 @@ pub extern "C" fn SiPrefix_to_str(o: &crate::lightning_invoice::SiPrefix) -> Str mod tb { use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -164,17 +158,7 @@ use alloc::{vec::Vec, boxed::Box}; mod prelude { 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 sync { - -use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -188,7 +172,7 @@ use alloc::{vec::Vec, boxed::Box}; #[derive(Clone)] #[must_use] #[repr(C)] -pub enum ParseError { +pub enum Bolt11ParseError { Bech32Error( crate::c_types::Bech32Error), ParseAmountError( @@ -215,284 +199,298 @@ pub enum ParseError { /// according to BOLT11 Skip, } -use lightning_invoice::ParseError as ParseErrorImport; -pub(crate) type nativeParseError = ParseErrorImport; +use lightning_invoice::Bolt11ParseError as Bolt11ParseErrorImport; +pub(crate) type nativeBolt11ParseError = Bolt11ParseErrorImport; -impl ParseError { +impl Bolt11ParseError { #[allow(unused)] - pub(crate) fn to_native(&self) -> nativeParseError { + pub(crate) fn to_native(&self) -> nativeBolt11ParseError { match self { - ParseError::Bech32Error (ref a, ) => { + Bolt11ParseError::Bech32Error (ref a, ) => { let mut a_nonref = Clone::clone(a); - nativeParseError::Bech32Error ( + nativeBolt11ParseError::Bech32Error ( a_nonref.into_rust(), ) }, - ParseError::ParseAmountError (ref a, ) => { + Bolt11ParseError::ParseAmountError (ref a, ) => { let mut a_nonref = Clone::clone(a); - nativeParseError::ParseAmountError ( + nativeBolt11ParseError::ParseAmountError ( u8::from_str_radix(" a", 10).unwrap_err() /*a_nonref*/, ) }, - ParseError::MalformedSignature (ref a, ) => { + Bolt11ParseError::MalformedSignature (ref a, ) => { let mut a_nonref = Clone::clone(a); - nativeParseError::MalformedSignature ( + nativeBolt11ParseError::MalformedSignature ( a_nonref.into_rust(), ) }, - ParseError::BadPrefix => nativeParseError::BadPrefix, - ParseError::UnknownCurrency => nativeParseError::UnknownCurrency, - ParseError::UnknownSiPrefix => nativeParseError::UnknownSiPrefix, - ParseError::MalformedHRP => nativeParseError::MalformedHRP, - ParseError::TooShortDataPart => nativeParseError::TooShortDataPart, - ParseError::UnexpectedEndOfTaggedFields => nativeParseError::UnexpectedEndOfTaggedFields, - ParseError::DescriptionDecodeError (ref a, ) => { + Bolt11ParseError::BadPrefix => nativeBolt11ParseError::BadPrefix, + Bolt11ParseError::UnknownCurrency => nativeBolt11ParseError::UnknownCurrency, + Bolt11ParseError::UnknownSiPrefix => nativeBolt11ParseError::UnknownSiPrefix, + Bolt11ParseError::MalformedHRP => nativeBolt11ParseError::MalformedHRP, + Bolt11ParseError::TooShortDataPart => nativeBolt11ParseError::TooShortDataPart, + Bolt11ParseError::UnexpectedEndOfTaggedFields => nativeBolt11ParseError::UnexpectedEndOfTaggedFields, + Bolt11ParseError::DescriptionDecodeError (ref a, ) => { let mut a_nonref = Clone::clone(a); - nativeParseError::DescriptionDecodeError ( + nativeBolt11ParseError::DescriptionDecodeError ( core::str::from_utf8(&[0xff]).unwrap_err() /*a_nonref*/, ) }, - ParseError::PaddingError => nativeParseError::PaddingError, - ParseError::IntegerOverflowError => nativeParseError::IntegerOverflowError, - ParseError::InvalidSegWitProgramLength => nativeParseError::InvalidSegWitProgramLength, - ParseError::InvalidPubKeyHashLength => nativeParseError::InvalidPubKeyHashLength, - ParseError::InvalidScriptHashLength => nativeParseError::InvalidScriptHashLength, - ParseError::InvalidRecoveryId => nativeParseError::InvalidRecoveryId, - ParseError::InvalidSliceLength (ref a, ) => { + Bolt11ParseError::PaddingError => nativeBolt11ParseError::PaddingError, + Bolt11ParseError::IntegerOverflowError => nativeBolt11ParseError::IntegerOverflowError, + Bolt11ParseError::InvalidSegWitProgramLength => nativeBolt11ParseError::InvalidSegWitProgramLength, + Bolt11ParseError::InvalidPubKeyHashLength => nativeBolt11ParseError::InvalidPubKeyHashLength, + Bolt11ParseError::InvalidScriptHashLength => nativeBolt11ParseError::InvalidScriptHashLength, + Bolt11ParseError::InvalidRecoveryId => nativeBolt11ParseError::InvalidRecoveryId, + Bolt11ParseError::InvalidSliceLength (ref a, ) => { let mut a_nonref = Clone::clone(a); - nativeParseError::InvalidSliceLength ( + nativeBolt11ParseError::InvalidSliceLength ( a_nonref.into_string(), ) }, - ParseError::Skip => nativeParseError::Skip, + Bolt11ParseError::Skip => nativeBolt11ParseError::Skip, } } #[allow(unused)] - pub(crate) fn into_native(self) -> nativeParseError { + pub(crate) fn into_native(self) -> nativeBolt11ParseError { match self { - ParseError::Bech32Error (mut a, ) => { - nativeParseError::Bech32Error ( + Bolt11ParseError::Bech32Error (mut a, ) => { + nativeBolt11ParseError::Bech32Error ( a.into_rust(), ) }, - ParseError::ParseAmountError (mut a, ) => { - nativeParseError::ParseAmountError ( + Bolt11ParseError::ParseAmountError (mut a, ) => { + nativeBolt11ParseError::ParseAmountError ( u8::from_str_radix(" a", 10).unwrap_err() /*a*/, ) }, - ParseError::MalformedSignature (mut a, ) => { - nativeParseError::MalformedSignature ( + Bolt11ParseError::MalformedSignature (mut a, ) => { + nativeBolt11ParseError::MalformedSignature ( a.into_rust(), ) }, - ParseError::BadPrefix => nativeParseError::BadPrefix, - ParseError::UnknownCurrency => nativeParseError::UnknownCurrency, - ParseError::UnknownSiPrefix => nativeParseError::UnknownSiPrefix, - ParseError::MalformedHRP => nativeParseError::MalformedHRP, - ParseError::TooShortDataPart => nativeParseError::TooShortDataPart, - ParseError::UnexpectedEndOfTaggedFields => nativeParseError::UnexpectedEndOfTaggedFields, - ParseError::DescriptionDecodeError (mut a, ) => { - nativeParseError::DescriptionDecodeError ( + Bolt11ParseError::BadPrefix => nativeBolt11ParseError::BadPrefix, + Bolt11ParseError::UnknownCurrency => nativeBolt11ParseError::UnknownCurrency, + Bolt11ParseError::UnknownSiPrefix => nativeBolt11ParseError::UnknownSiPrefix, + Bolt11ParseError::MalformedHRP => nativeBolt11ParseError::MalformedHRP, + Bolt11ParseError::TooShortDataPart => nativeBolt11ParseError::TooShortDataPart, + Bolt11ParseError::UnexpectedEndOfTaggedFields => nativeBolt11ParseError::UnexpectedEndOfTaggedFields, + Bolt11ParseError::DescriptionDecodeError (mut a, ) => { + nativeBolt11ParseError::DescriptionDecodeError ( core::str::from_utf8(&[0xff]).unwrap_err() /*a*/, ) }, - ParseError::PaddingError => nativeParseError::PaddingError, - ParseError::IntegerOverflowError => nativeParseError::IntegerOverflowError, - ParseError::InvalidSegWitProgramLength => nativeParseError::InvalidSegWitProgramLength, - ParseError::InvalidPubKeyHashLength => nativeParseError::InvalidPubKeyHashLength, - ParseError::InvalidScriptHashLength => nativeParseError::InvalidScriptHashLength, - ParseError::InvalidRecoveryId => nativeParseError::InvalidRecoveryId, - ParseError::InvalidSliceLength (mut a, ) => { - nativeParseError::InvalidSliceLength ( + Bolt11ParseError::PaddingError => nativeBolt11ParseError::PaddingError, + Bolt11ParseError::IntegerOverflowError => nativeBolt11ParseError::IntegerOverflowError, + Bolt11ParseError::InvalidSegWitProgramLength => nativeBolt11ParseError::InvalidSegWitProgramLength, + Bolt11ParseError::InvalidPubKeyHashLength => nativeBolt11ParseError::InvalidPubKeyHashLength, + Bolt11ParseError::InvalidScriptHashLength => nativeBolt11ParseError::InvalidScriptHashLength, + Bolt11ParseError::InvalidRecoveryId => nativeBolt11ParseError::InvalidRecoveryId, + Bolt11ParseError::InvalidSliceLength (mut a, ) => { + nativeBolt11ParseError::InvalidSliceLength ( a.into_string(), ) }, - ParseError::Skip => nativeParseError::Skip, + Bolt11ParseError::Skip => nativeBolt11ParseError::Skip, } } #[allow(unused)] - pub(crate) fn from_native(native: &nativeParseError) -> Self { + pub(crate) fn from_native(native: &Bolt11ParseErrorImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativeBolt11ParseError) }; match native { - nativeParseError::Bech32Error (ref a, ) => { + nativeBolt11ParseError::Bech32Error (ref a, ) => { let mut a_nonref = Clone::clone(a); - ParseError::Bech32Error ( + Bolt11ParseError::Bech32Error ( crate::c_types::Bech32Error::from_rust(a_nonref), ) }, - nativeParseError::ParseAmountError (ref a, ) => { + nativeBolt11ParseError::ParseAmountError (ref a, ) => { let mut a_nonref = Clone::clone(a); - ParseError::ParseAmountError ( + Bolt11ParseError::ParseAmountError ( crate::c_types::Error { _dummy: 0 } /*a_nonref*/, ) }, - nativeParseError::MalformedSignature (ref a, ) => { + nativeBolt11ParseError::MalformedSignature (ref a, ) => { let mut a_nonref = Clone::clone(a); - ParseError::MalformedSignature ( + Bolt11ParseError::MalformedSignature ( crate::c_types::Secp256k1Error::from_rust(a_nonref), ) }, - nativeParseError::BadPrefix => ParseError::BadPrefix, - nativeParseError::UnknownCurrency => ParseError::UnknownCurrency, - nativeParseError::UnknownSiPrefix => ParseError::UnknownSiPrefix, - nativeParseError::MalformedHRP => ParseError::MalformedHRP, - nativeParseError::TooShortDataPart => ParseError::TooShortDataPart, - nativeParseError::UnexpectedEndOfTaggedFields => ParseError::UnexpectedEndOfTaggedFields, - nativeParseError::DescriptionDecodeError (ref a, ) => { + nativeBolt11ParseError::BadPrefix => Bolt11ParseError::BadPrefix, + nativeBolt11ParseError::UnknownCurrency => Bolt11ParseError::UnknownCurrency, + nativeBolt11ParseError::UnknownSiPrefix => Bolt11ParseError::UnknownSiPrefix, + nativeBolt11ParseError::MalformedHRP => Bolt11ParseError::MalformedHRP, + nativeBolt11ParseError::TooShortDataPart => Bolt11ParseError::TooShortDataPart, + nativeBolt11ParseError::UnexpectedEndOfTaggedFields => Bolt11ParseError::UnexpectedEndOfTaggedFields, + nativeBolt11ParseError::DescriptionDecodeError (ref a, ) => { let mut a_nonref = Clone::clone(a); - ParseError::DescriptionDecodeError ( + Bolt11ParseError::DescriptionDecodeError ( crate::c_types::Error { _dummy: 0 } /*a_nonref*/, ) }, - nativeParseError::PaddingError => ParseError::PaddingError, - nativeParseError::IntegerOverflowError => ParseError::IntegerOverflowError, - nativeParseError::InvalidSegWitProgramLength => ParseError::InvalidSegWitProgramLength, - nativeParseError::InvalidPubKeyHashLength => ParseError::InvalidPubKeyHashLength, - nativeParseError::InvalidScriptHashLength => ParseError::InvalidScriptHashLength, - nativeParseError::InvalidRecoveryId => ParseError::InvalidRecoveryId, - nativeParseError::InvalidSliceLength (ref a, ) => { + nativeBolt11ParseError::PaddingError => Bolt11ParseError::PaddingError, + nativeBolt11ParseError::IntegerOverflowError => Bolt11ParseError::IntegerOverflowError, + nativeBolt11ParseError::InvalidSegWitProgramLength => Bolt11ParseError::InvalidSegWitProgramLength, + nativeBolt11ParseError::InvalidPubKeyHashLength => Bolt11ParseError::InvalidPubKeyHashLength, + nativeBolt11ParseError::InvalidScriptHashLength => Bolt11ParseError::InvalidScriptHashLength, + nativeBolt11ParseError::InvalidRecoveryId => Bolt11ParseError::InvalidRecoveryId, + nativeBolt11ParseError::InvalidSliceLength (ref a, ) => { let mut a_nonref = Clone::clone(a); - ParseError::InvalidSliceLength ( + Bolt11ParseError::InvalidSliceLength ( a_nonref.into(), ) }, - nativeParseError::Skip => ParseError::Skip, + nativeBolt11ParseError::Skip => Bolt11ParseError::Skip, } } #[allow(unused)] - pub(crate) fn native_into(native: nativeParseError) -> Self { + pub(crate) fn native_into(native: nativeBolt11ParseError) -> Self { match native { - nativeParseError::Bech32Error (mut a, ) => { - ParseError::Bech32Error ( + nativeBolt11ParseError::Bech32Error (mut a, ) => { + Bolt11ParseError::Bech32Error ( crate::c_types::Bech32Error::from_rust(a), ) }, - nativeParseError::ParseAmountError (mut a, ) => { - ParseError::ParseAmountError ( + nativeBolt11ParseError::ParseAmountError (mut a, ) => { + Bolt11ParseError::ParseAmountError ( crate::c_types::Error { _dummy: 0 } /*a*/, ) }, - nativeParseError::MalformedSignature (mut a, ) => { - ParseError::MalformedSignature ( + nativeBolt11ParseError::MalformedSignature (mut a, ) => { + Bolt11ParseError::MalformedSignature ( crate::c_types::Secp256k1Error::from_rust(a), ) }, - nativeParseError::BadPrefix => ParseError::BadPrefix, - nativeParseError::UnknownCurrency => ParseError::UnknownCurrency, - nativeParseError::UnknownSiPrefix => ParseError::UnknownSiPrefix, - nativeParseError::MalformedHRP => ParseError::MalformedHRP, - nativeParseError::TooShortDataPart => ParseError::TooShortDataPart, - nativeParseError::UnexpectedEndOfTaggedFields => ParseError::UnexpectedEndOfTaggedFields, - nativeParseError::DescriptionDecodeError (mut a, ) => { - ParseError::DescriptionDecodeError ( + nativeBolt11ParseError::BadPrefix => Bolt11ParseError::BadPrefix, + nativeBolt11ParseError::UnknownCurrency => Bolt11ParseError::UnknownCurrency, + nativeBolt11ParseError::UnknownSiPrefix => Bolt11ParseError::UnknownSiPrefix, + nativeBolt11ParseError::MalformedHRP => Bolt11ParseError::MalformedHRP, + nativeBolt11ParseError::TooShortDataPart => Bolt11ParseError::TooShortDataPart, + nativeBolt11ParseError::UnexpectedEndOfTaggedFields => Bolt11ParseError::UnexpectedEndOfTaggedFields, + nativeBolt11ParseError::DescriptionDecodeError (mut a, ) => { + Bolt11ParseError::DescriptionDecodeError ( crate::c_types::Error { _dummy: 0 } /*a*/, ) }, - nativeParseError::PaddingError => ParseError::PaddingError, - nativeParseError::IntegerOverflowError => ParseError::IntegerOverflowError, - nativeParseError::InvalidSegWitProgramLength => ParseError::InvalidSegWitProgramLength, - nativeParseError::InvalidPubKeyHashLength => ParseError::InvalidPubKeyHashLength, - nativeParseError::InvalidScriptHashLength => ParseError::InvalidScriptHashLength, - nativeParseError::InvalidRecoveryId => ParseError::InvalidRecoveryId, - nativeParseError::InvalidSliceLength (mut a, ) => { - ParseError::InvalidSliceLength ( + nativeBolt11ParseError::PaddingError => Bolt11ParseError::PaddingError, + nativeBolt11ParseError::IntegerOverflowError => Bolt11ParseError::IntegerOverflowError, + nativeBolt11ParseError::InvalidSegWitProgramLength => Bolt11ParseError::InvalidSegWitProgramLength, + nativeBolt11ParseError::InvalidPubKeyHashLength => Bolt11ParseError::InvalidPubKeyHashLength, + nativeBolt11ParseError::InvalidScriptHashLength => Bolt11ParseError::InvalidScriptHashLength, + nativeBolt11ParseError::InvalidRecoveryId => Bolt11ParseError::InvalidRecoveryId, + nativeBolt11ParseError::InvalidSliceLength (mut a, ) => { + Bolt11ParseError::InvalidSliceLength ( a.into(), ) }, - nativeParseError::Skip => ParseError::Skip, + nativeBolt11ParseError::Skip => Bolt11ParseError::Skip, } } } -/// Frees any resources used by the ParseError +/// Frees any resources used by the Bolt11ParseError #[no_mangle] -pub extern "C" fn ParseError_free(this_ptr: ParseError) { } -/// Creates a copy of the ParseError +pub extern "C" fn Bolt11ParseError_free(this_ptr: Bolt11ParseError) { } +/// Creates a copy of the Bolt11ParseError #[no_mangle] -pub extern "C" fn ParseError_clone(orig: &ParseError) -> ParseError { +pub extern "C" fn Bolt11ParseError_clone(orig: &Bolt11ParseError) -> Bolt11ParseError { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Bolt11ParseError_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const Bolt11ParseError)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Bolt11ParseError_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut Bolt11ParseError) }; +} #[no_mangle] -/// Utility method to constructs a new Bech32Error-variant ParseError -pub extern "C" fn ParseError_bech32_error(a: crate::c_types::Bech32Error) -> ParseError { - ParseError::Bech32Error(a, ) +/// Utility method to constructs a new Bech32Error-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_bech32_error(a: crate::c_types::Bech32Error) -> Bolt11ParseError { + Bolt11ParseError::Bech32Error(a, ) } #[no_mangle] -/// Utility method to constructs a new ParseAmountError-variant ParseError -pub extern "C" fn ParseError_parse_amount_error(a: crate::c_types::Error) -> ParseError { - ParseError::ParseAmountError(a, ) +/// Utility method to constructs a new ParseAmountError-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_parse_amount_error(a: crate::c_types::Error) -> Bolt11ParseError { + Bolt11ParseError::ParseAmountError(a, ) } #[no_mangle] -/// Utility method to constructs a new MalformedSignature-variant ParseError -pub extern "C" fn ParseError_malformed_signature(a: crate::c_types::Secp256k1Error) -> ParseError { - ParseError::MalformedSignature(a, ) +/// Utility method to constructs a new MalformedSignature-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_malformed_signature(a: crate::c_types::Secp256k1Error) -> Bolt11ParseError { + Bolt11ParseError::MalformedSignature(a, ) } #[no_mangle] -/// Utility method to constructs a new BadPrefix-variant ParseError -pub extern "C" fn ParseError_bad_prefix() -> ParseError { - ParseError::BadPrefix} +/// Utility method to constructs a new BadPrefix-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_bad_prefix() -> Bolt11ParseError { + Bolt11ParseError::BadPrefix} #[no_mangle] -/// Utility method to constructs a new UnknownCurrency-variant ParseError -pub extern "C" fn ParseError_unknown_currency() -> ParseError { - ParseError::UnknownCurrency} +/// Utility method to constructs a new UnknownCurrency-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_unknown_currency() -> Bolt11ParseError { + Bolt11ParseError::UnknownCurrency} #[no_mangle] -/// Utility method to constructs a new UnknownSiPrefix-variant ParseError -pub extern "C" fn ParseError_unknown_si_prefix() -> ParseError { - ParseError::UnknownSiPrefix} +/// Utility method to constructs a new UnknownSiPrefix-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_unknown_si_prefix() -> Bolt11ParseError { + Bolt11ParseError::UnknownSiPrefix} #[no_mangle] -/// Utility method to constructs a new MalformedHRP-variant ParseError -pub extern "C" fn ParseError_malformed_hrp() -> ParseError { - ParseError::MalformedHRP} +/// Utility method to constructs a new MalformedHRP-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_malformed_hrp() -> Bolt11ParseError { + Bolt11ParseError::MalformedHRP} #[no_mangle] -/// Utility method to constructs a new TooShortDataPart-variant ParseError -pub extern "C" fn ParseError_too_short_data_part() -> ParseError { - ParseError::TooShortDataPart} +/// Utility method to constructs a new TooShortDataPart-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_too_short_data_part() -> Bolt11ParseError { + Bolt11ParseError::TooShortDataPart} #[no_mangle] -/// Utility method to constructs a new UnexpectedEndOfTaggedFields-variant ParseError -pub extern "C" fn ParseError_unexpected_end_of_tagged_fields() -> ParseError { - ParseError::UnexpectedEndOfTaggedFields} +/// Utility method to constructs a new UnexpectedEndOfTaggedFields-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_unexpected_end_of_tagged_fields() -> Bolt11ParseError { + Bolt11ParseError::UnexpectedEndOfTaggedFields} #[no_mangle] -/// Utility method to constructs a new DescriptionDecodeError-variant ParseError -pub extern "C" fn ParseError_description_decode_error(a: crate::c_types::Error) -> ParseError { - ParseError::DescriptionDecodeError(a, ) +/// Utility method to constructs a new DescriptionDecodeError-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_description_decode_error(a: crate::c_types::Error) -> Bolt11ParseError { + Bolt11ParseError::DescriptionDecodeError(a, ) } #[no_mangle] -/// Utility method to constructs a new PaddingError-variant ParseError -pub extern "C" fn ParseError_padding_error() -> ParseError { - ParseError::PaddingError} +/// Utility method to constructs a new PaddingError-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_padding_error() -> Bolt11ParseError { + Bolt11ParseError::PaddingError} #[no_mangle] -/// Utility method to constructs a new IntegerOverflowError-variant ParseError -pub extern "C" fn ParseError_integer_overflow_error() -> ParseError { - ParseError::IntegerOverflowError} +/// Utility method to constructs a new IntegerOverflowError-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_integer_overflow_error() -> Bolt11ParseError { + Bolt11ParseError::IntegerOverflowError} #[no_mangle] -/// Utility method to constructs a new InvalidSegWitProgramLength-variant ParseError -pub extern "C" fn ParseError_invalid_seg_wit_program_length() -> ParseError { - ParseError::InvalidSegWitProgramLength} +/// Utility method to constructs a new InvalidSegWitProgramLength-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_invalid_seg_wit_program_length() -> Bolt11ParseError { + Bolt11ParseError::InvalidSegWitProgramLength} #[no_mangle] -/// Utility method to constructs a new InvalidPubKeyHashLength-variant ParseError -pub extern "C" fn ParseError_invalid_pub_key_hash_length() -> ParseError { - ParseError::InvalidPubKeyHashLength} +/// Utility method to constructs a new InvalidPubKeyHashLength-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_invalid_pub_key_hash_length() -> Bolt11ParseError { + Bolt11ParseError::InvalidPubKeyHashLength} #[no_mangle] -/// Utility method to constructs a new InvalidScriptHashLength-variant ParseError -pub extern "C" fn ParseError_invalid_script_hash_length() -> ParseError { - ParseError::InvalidScriptHashLength} +/// Utility method to constructs a new InvalidScriptHashLength-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_invalid_script_hash_length() -> Bolt11ParseError { + Bolt11ParseError::InvalidScriptHashLength} #[no_mangle] -/// Utility method to constructs a new InvalidRecoveryId-variant ParseError -pub extern "C" fn ParseError_invalid_recovery_id() -> ParseError { - ParseError::InvalidRecoveryId} +/// Utility method to constructs a new InvalidRecoveryId-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_invalid_recovery_id() -> Bolt11ParseError { + Bolt11ParseError::InvalidRecoveryId} #[no_mangle] -/// Utility method to constructs a new InvalidSliceLength-variant ParseError -pub extern "C" fn ParseError_invalid_slice_length(a: crate::c_types::Str) -> ParseError { - ParseError::InvalidSliceLength(a, ) +/// Utility method to constructs a new InvalidSliceLength-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_invalid_slice_length(a: crate::c_types::Str) -> Bolt11ParseError { + Bolt11ParseError::InvalidSliceLength(a, ) } #[no_mangle] -/// Utility method to constructs a new Skip-variant ParseError -pub extern "C" fn ParseError_skip() -> ParseError { - ParseError::Skip} -/// Checks if two ParseErrors contain equal inner contents. +/// Utility method to constructs a new Skip-variant Bolt11ParseError +pub extern "C" fn Bolt11ParseError_skip() -> Bolt11ParseError { + Bolt11ParseError::Skip} +/// Checks if two Bolt11ParseErrors 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 { +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. @@ -502,10 +500,10 @@ pub extern "C" fn ParseError_eq(a: &ParseError, b: &ParseError) -> bool { pub enum ParseOrSemanticError { /// The invoice couldn't be decoded ParseError( - crate::lightning_invoice::ParseError), + crate::lightning_invoice::Bolt11ParseError), /// The invoice could be decoded but violates the BOLT11 standard SemanticError( - crate::lightning_invoice::SemanticError), + crate::lightning_invoice::Bolt11SemanticError), } use lightning_invoice::ParseOrSemanticError as ParseOrSemanticErrorImport; pub(crate) type nativeParseOrSemanticError = ParseOrSemanticErrorImport; @@ -544,18 +542,19 @@ impl ParseOrSemanticError { } } #[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); ParseOrSemanticError::ParseError ( - crate::lightning_invoice::ParseError::native_into(a_nonref), + crate::lightning_invoice::Bolt11ParseError::native_into(a_nonref), ) }, nativeParseOrSemanticError::SemanticError (ref a, ) => { let mut a_nonref = Clone::clone(a); ParseOrSemanticError::SemanticError ( - crate::lightning_invoice::SemanticError::native_into(a_nonref), + crate::lightning_invoice::Bolt11SemanticError::native_into(a_nonref), ) }, } @@ -565,12 +564,12 @@ impl ParseOrSemanticError { match native { nativeParseOrSemanticError::ParseError (mut a, ) => { ParseOrSemanticError::ParseError ( - crate::lightning_invoice::ParseError::native_into(a), + crate::lightning_invoice::Bolt11ParseError::native_into(a), ) }, nativeParseOrSemanticError::SemanticError (mut a, ) => { ParseOrSemanticError::SemanticError ( - crate::lightning_invoice::SemanticError::native_into(a), + crate::lightning_invoice::Bolt11SemanticError::native_into(a), ) }, } @@ -584,14 +583,24 @@ pub extern "C" fn ParseOrSemanticError_free(this_ptr: ParseOrSemanticError) { } pub extern "C" fn ParseOrSemanticError_clone(orig: &ParseOrSemanticError) -> ParseOrSemanticError { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ParseOrSemanticError_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const ParseOrSemanticError)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ParseOrSemanticError_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut ParseOrSemanticError) }; +} #[no_mangle] /// Utility method to constructs a new ParseError-variant ParseOrSemanticError -pub extern "C" fn ParseOrSemanticError_parse_error(a: crate::lightning_invoice::ParseError) -> ParseOrSemanticError { +pub extern "C" fn ParseOrSemanticError_parse_error(a: crate::lightning_invoice::Bolt11ParseError) -> ParseOrSemanticError { ParseOrSemanticError::ParseError(a, ) } #[no_mangle] /// Utility method to constructs a new SemanticError-variant ParseOrSemanticError -pub extern "C" fn ParseOrSemanticError_semantic_error(a: crate::lightning_invoice::SemanticError) -> ParseOrSemanticError { +pub extern "C" fn ParseOrSemanticError_semantic_error(a: crate::lightning_invoice::Bolt11SemanticError) -> ParseOrSemanticError { ParseOrSemanticError::SemanticError(a, ) } /// Checks if two ParseOrSemanticErrors contain equal inner contents. @@ -600,6 +609,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 } } +/// 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 @@ -623,25 +635,25 @@ pub static DEFAULT_EXPIRY_TIME: u64 = lightning_invoice::DEFAULT_EXPIRY_TIME; #[no_mangle] 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; +use lightning_invoice::Bolt11Invoice as nativeBolt11InvoiceImport; +pub(crate) type nativeBolt11Invoice = nativeBolt11InvoiceImport; /// Represents a syntactically and semantically correct lightning BOLT11 invoice. /// -/// There are three ways to construct an `Invoice`: +/// There are three ways to construct a `Bolt11Invoice`: /// 1. using [`InvoiceBuilder`] -/// 2. using [`Invoice::from_signed`] -/// 3. using `str::parse::(&str)` (see [`Invoice::from_str`]) +/// 2. using [`Bolt11Invoice::from_signed`] +/// 3. using `str::parse::(&str)` (see [`Bolt11Invoice::from_str`]) /// -/// [`Invoice::from_str`]: crate::Invoice#impl-FromStr +/// [`Bolt11Invoice::from_str`]: crate::Bolt11Invoice#impl-FromStr #[must_use] #[repr(C)] -pub struct Invoice { +pub struct Bolt11Invoice { /// 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 nativeInvoice, + pub inner: *mut nativeBolt11Invoice, /// 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 @@ -649,50 +661,53 @@ pub struct Invoice { pub is_owned: bool, } -impl Drop for Invoice { +impl Drop for Bolt11Invoice { fn drop(&mut self) { - if self.is_owned && !<*mut nativeInvoice>::is_null(self.inner) { + if self.is_owned && !<*mut nativeBolt11Invoice>::is_null(self.inner) { let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; } } } -/// Frees any resources used by the Invoice, if is_owned is set and inner is non-NULL. +/// Frees any resources used by the Bolt11Invoice, if is_owned is set and inner is non-NULL. #[no_mangle] -pub extern "C" fn Invoice_free(this_obj: Invoice) { } +pub extern "C" fn Bolt11Invoice_free(this_obj: Bolt11Invoice) { } #[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) { - let _ = unsafe { Box::from_raw(this_ptr as *mut nativeInvoice) }; +pub(crate) extern "C" fn Bolt11Invoice_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeBolt11Invoice) }; } #[allow(unused)] -impl Invoice { - pub(crate) fn get_native_ref(&self) -> &'static nativeInvoice { +impl Bolt11Invoice { + pub(crate) fn get_native_ref(&self) -> &'static nativeBolt11Invoice { unsafe { &*ObjOps::untweak_ptr(self.inner) } } - pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeInvoice { + pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeBolt11Invoice { 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 nativeInvoice { + pub(crate) fn take_inner(mut self) -> *mut nativeBolt11Invoice { assert!(self.is_owned); let ret = ObjOps::untweak_ptr(self.inner); self.inner = core::ptr::null_mut(); ret } } -/// Checks if two Invoices contain equal inner contents. +/// Checks if two Bolt11Invoices 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 Invoice_eq(a: &Invoice, b: &Invoice) -> bool { +pub extern "C" fn Bolt11Invoice_eq(a: &Bolt11Invoice, b: &Bolt11Invoice) -> 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 } } -impl Clone for Invoice { +/// 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 { - inner: if <*mut nativeInvoice>::is_null(self.inner) { core::ptr::null_mut() } else { + inner: if <*mut nativeBolt11Invoice>::is_null(self.inner) { core::ptr::null_mut() } else { ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) }, is_owned: true, } @@ -700,17 +715,17 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInvoice)).clone() })) as *mut c_void +pub(crate) extern "C" fn Bolt11Invoice_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeBolt11Invoice)).clone() })) as *mut c_void } #[no_mangle] -/// Creates a copy of the Invoice -pub extern "C" fn Invoice_clone(orig: &Invoice) -> Invoice { +/// Creates a copy of the Bolt11Invoice +pub extern "C" fn Bolt11Invoice_clone(orig: &Bolt11Invoice) -> Bolt11Invoice { orig.clone() } -/// Generates a non-cryptographic 64-bit hash of the Invoice. +/// Generates a non-cryptographic 64-bit hash of the Bolt11Invoice. #[no_mangle] -pub extern "C" fn Invoice_hash(o: &Invoice) -> u64 { +pub extern "C" fn Bolt11Invoice_hash(o: &Bolt11Invoice) -> 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)] @@ -719,22 +734,22 @@ pub extern "C" fn Invoice_hash(o: &Invoice) -> u64 { core::hash::Hasher::finish(&hasher) } -use lightning_invoice::SignedRawInvoice as nativeSignedRawInvoiceImport; -pub(crate) type nativeSignedRawInvoice = nativeSignedRawInvoiceImport; +use lightning_invoice::SignedRawBolt11Invoice as nativeSignedRawBolt11InvoiceImport; +pub(crate) type nativeSignedRawBolt11Invoice = nativeSignedRawBolt11InvoiceImport; -/// Represents a signed [`RawInvoice`] with cached hash. The signature is not checked and may be +/// Represents a signed [`RawBolt11Invoice`] with cached hash. The signature is not checked and may be /// invalid. /// /// # Invariants -/// The hash has to be either from the deserialized invoice or from the serialized [`RawInvoice`]. +/// The hash has to be either from the deserialized invoice or from the serialized [`RawBolt11Invoice`]. #[must_use] #[repr(C)] -pub struct SignedRawInvoice { +pub struct SignedRawBolt11Invoice { /// 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 nativeSignedRawInvoice, + pub inner: *mut nativeSignedRawBolt11Invoice, /// 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 @@ -742,50 +757,53 @@ pub struct SignedRawInvoice { pub is_owned: bool, } -impl Drop for SignedRawInvoice { +impl Drop for SignedRawBolt11Invoice { fn drop(&mut self) { - if self.is_owned && !<*mut nativeSignedRawInvoice>::is_null(self.inner) { + if self.is_owned && !<*mut nativeSignedRawBolt11Invoice>::is_null(self.inner) { let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; } } } -/// Frees any resources used by the SignedRawInvoice, if is_owned is set and inner is non-NULL. +/// Frees any resources used by the SignedRawBolt11Invoice, if is_owned is set and inner is non-NULL. #[no_mangle] -pub extern "C" fn SignedRawInvoice_free(this_obj: SignedRawInvoice) { } +pub extern "C" fn SignedRawBolt11Invoice_free(this_obj: SignedRawBolt11Invoice) { } #[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) { - let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSignedRawInvoice) }; +pub(crate) extern "C" fn SignedRawBolt11Invoice_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeSignedRawBolt11Invoice) }; } #[allow(unused)] -impl SignedRawInvoice { - pub(crate) fn get_native_ref(&self) -> &'static nativeSignedRawInvoice { +impl SignedRawBolt11Invoice { + pub(crate) fn get_native_ref(&self) -> &'static nativeSignedRawBolt11Invoice { unsafe { &*ObjOps::untweak_ptr(self.inner) } } - pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeSignedRawInvoice { + pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeSignedRawBolt11Invoice { 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 nativeSignedRawInvoice { + pub(crate) fn take_inner(mut self) -> *mut nativeSignedRawBolt11Invoice { assert!(self.is_owned); let ret = ObjOps::untweak_ptr(self.inner); self.inner = core::ptr::null_mut(); ret } } -/// Checks if two SignedRawInvoices contain equal inner contents. +/// Checks if two SignedRawBolt11Invoices 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 SignedRawInvoice_eq(a: &SignedRawInvoice, b: &SignedRawInvoice) -> bool { +pub extern "C" fn SignedRawBolt11Invoice_eq(a: &SignedRawBolt11Invoice, b: &SignedRawBolt11Invoice) -> 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 } } -impl Clone for SignedRawInvoice { +/// 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 { - inner: if <*mut nativeSignedRawInvoice>::is_null(self.inner) { core::ptr::null_mut() } else { + inner: if <*mut nativeSignedRawBolt11Invoice>::is_null(self.inner) { core::ptr::null_mut() } else { ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) }, is_owned: true, } @@ -793,17 +811,17 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeSignedRawInvoice)).clone() })) as *mut c_void +pub(crate) extern "C" fn SignedRawBolt11Invoice_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeSignedRawBolt11Invoice)).clone() })) as *mut c_void } #[no_mangle] -/// Creates a copy of the SignedRawInvoice -pub extern "C" fn SignedRawInvoice_clone(orig: &SignedRawInvoice) -> SignedRawInvoice { +/// Creates a copy of the SignedRawBolt11Invoice +pub extern "C" fn SignedRawBolt11Invoice_clone(orig: &SignedRawBolt11Invoice) -> SignedRawBolt11Invoice { orig.clone() } -/// Generates a non-cryptographic 64-bit hash of the SignedRawInvoice. +/// Generates a non-cryptographic 64-bit hash of the SignedRawBolt11Invoice. #[no_mangle] -pub extern "C" fn SignedRawInvoice_hash(o: &SignedRawInvoice) -> u64 { +pub extern "C" fn SignedRawBolt11Invoice_hash(o: &SignedRawBolt11Invoice) -> 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)] @@ -812,22 +830,22 @@ pub extern "C" fn SignedRawInvoice_hash(o: &SignedRawInvoice) -> u64 { core::hash::Hasher::finish(&hasher) } -use lightning_invoice::RawInvoice as nativeRawInvoiceImport; -pub(crate) type nativeRawInvoice = nativeRawInvoiceImport; +use lightning_invoice::RawBolt11Invoice as nativeRawBolt11InvoiceImport; +pub(crate) type nativeRawBolt11Invoice = nativeRawBolt11InvoiceImport; -/// Represents an syntactically correct [`Invoice`] for a payment on the lightning network, +/// Represents an syntactically correct [`Bolt11Invoice`] for a payment on the lightning network, /// but without the signature information. /// Decoding and encoding should not lead to information loss but may lead to different hashes. /// -/// For methods without docs see the corresponding methods in [`Invoice`]. +/// For methods without docs see the corresponding methods in [`Bolt11Invoice`]. #[must_use] #[repr(C)] -pub struct RawInvoice { +pub struct RawBolt11Invoice { /// 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 nativeRawInvoice, + pub inner: *mut nativeRawBolt11Invoice, /// 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 @@ -835,31 +853,31 @@ pub struct RawInvoice { pub is_owned: bool, } -impl Drop for RawInvoice { +impl Drop for RawBolt11Invoice { fn drop(&mut self) { - if self.is_owned && !<*mut nativeRawInvoice>::is_null(self.inner) { + if self.is_owned && !<*mut nativeRawBolt11Invoice>::is_null(self.inner) { let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; } } } -/// Frees any resources used by the RawInvoice, if is_owned is set and inner is non-NULL. +/// Frees any resources used by the RawBolt11Invoice, if is_owned is set and inner is non-NULL. #[no_mangle] -pub extern "C" fn RawInvoice_free(this_obj: RawInvoice) { } +pub extern "C" fn RawBolt11Invoice_free(this_obj: RawBolt11Invoice) { } #[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) { - let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRawInvoice) }; +pub(crate) extern "C" fn RawBolt11Invoice_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRawBolt11Invoice) }; } #[allow(unused)] -impl RawInvoice { - pub(crate) fn get_native_ref(&self) -> &'static nativeRawInvoice { +impl RawBolt11Invoice { + pub(crate) fn get_native_ref(&self) -> &'static nativeRawBolt11Invoice { unsafe { &*ObjOps::untweak_ptr(self.inner) } } - pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRawInvoice { + pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRawBolt11Invoice { 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 nativeRawInvoice { + pub(crate) fn take_inner(mut self) -> *mut nativeRawBolt11Invoice { assert!(self.is_owned); let ret = ObjOps::untweak_ptr(self.inner); self.inner = core::ptr::null_mut(); @@ -868,28 +886,31 @@ impl RawInvoice { } /// data part #[no_mangle] -pub extern "C" fn RawInvoice_get_data(this_ptr: &RawInvoice) -> crate::lightning_invoice::RawDataPart { +pub extern "C" fn RawBolt11Invoice_get_data(this_ptr: &RawBolt11Invoice) -> crate::lightning_invoice::RawDataPart { let mut inner_val = &mut this_ptr.get_native_mut_ref().data; crate::lightning_invoice::RawDataPart { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning_invoice::RawDataPart<>) as *mut _) }, is_owned: false } } /// data part #[no_mangle] -pub extern "C" fn RawInvoice_set_data(this_ptr: &mut RawInvoice, mut val: crate::lightning_invoice::RawDataPart) { +pub extern "C" fn RawBolt11Invoice_set_data(this_ptr: &mut RawBolt11Invoice, mut val: crate::lightning_invoice::RawDataPart) { unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.data = *unsafe { Box::from_raw(val.take_inner()) }; } -/// Checks if two RawInvoices contain equal inner contents. +/// Checks if two RawBolt11Invoices 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 RawInvoice_eq(a: &RawInvoice, b: &RawInvoice) -> bool { +pub extern "C" fn RawBolt11Invoice_eq(a: &RawBolt11Invoice, b: &RawBolt11Invoice) -> 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 } } -impl Clone for RawInvoice { +/// 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 { - inner: if <*mut nativeRawInvoice>::is_null(self.inner) { core::ptr::null_mut() } else { + inner: if <*mut nativeRawBolt11Invoice>::is_null(self.inner) { core::ptr::null_mut() } else { ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) }, is_owned: true, } @@ -897,17 +918,17 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRawInvoice)).clone() })) as *mut c_void +pub(crate) extern "C" fn RawBolt11Invoice_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeRawBolt11Invoice)).clone() })) as *mut c_void } #[no_mangle] -/// Creates a copy of the RawInvoice -pub extern "C" fn RawInvoice_clone(orig: &RawInvoice) -> RawInvoice { +/// Creates a copy of the RawBolt11Invoice +pub extern "C" fn RawBolt11Invoice_clone(orig: &RawBolt11Invoice) -> RawBolt11Invoice { orig.clone() } -/// Generates a non-cryptographic 64-bit hash of the RawInvoice. +/// Generates a non-cryptographic 64-bit hash of the RawBolt11Invoice. #[no_mangle] -pub extern "C" fn RawInvoice_hash(o: &RawInvoice) -> u64 { +pub extern "C" fn RawBolt11Invoice_hash(o: &RawBolt11Invoice) -> 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)] @@ -919,7 +940,7 @@ pub extern "C" fn RawInvoice_hash(o: &RawInvoice) -> u64 { use lightning_invoice::RawDataPart as nativeRawDataPartImport; pub(crate) type nativeRawDataPart = nativeRawDataPartImport; -/// Data of the [`RawInvoice`] that is encoded in the data part +/// Data of the [`RawBolt11Invoice`] that is encoded in the data part #[must_use] #[repr(C)] pub struct RawDataPart { @@ -986,6 +1007,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 } } +/// 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 { @@ -998,7 +1022,7 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRawDataPart)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeRawDataPart)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the RawDataPart @@ -1080,6 +1104,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 } } +/// 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 { @@ -1092,7 +1119,7 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePositiveTimestamp)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativePositiveTimestamp)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the PositiveTimestamp @@ -1146,7 +1173,8 @@ impl SiPrefix { } } #[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, @@ -1169,6 +1197,16 @@ impl SiPrefix { pub extern "C" fn SiPrefix_clone(orig: &SiPrefix) -> SiPrefix { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn SiPrefix_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const SiPrefix)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn SiPrefix_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut SiPrefix) }; +} #[no_mangle] /// Utility method to constructs a new Milli-variant SiPrefix pub extern "C" fn SiPrefix_milli() -> SiPrefix { @@ -1191,6 +1229,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 } } +/// 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 { @@ -1250,7 +1291,8 @@ impl Currency { } } #[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, @@ -1275,6 +1317,16 @@ impl Currency { pub extern "C" fn Currency_clone(orig: &Currency) -> Currency { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Currency_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const Currency)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Currency_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut Currency) }; +} #[no_mangle] /// Utility method to constructs a new Bitcoin-variant Currency pub extern "C" fn Currency_bitcoin() -> Currency { @@ -1295,6 +1347,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} +/// 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 { @@ -1373,13 +1428,16 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeSha256)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeSha256)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the Sha256 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 { @@ -1474,13 +1532,16 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDescription)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeDescription)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the Description 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 { @@ -1580,13 +1641,16 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePayeePubKey)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativePayeePubKey)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the PayeePubKey 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 { @@ -1670,13 +1734,16 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeExpiryTime)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeExpiryTime)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the ExpiryTime 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 { @@ -1776,13 +1843,16 @@ impl Clone for 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 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 + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeMinFinalCltvExpiryDelta)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the MinFinalCltvExpiryDelta 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 { @@ -1835,13 +1905,13 @@ impl Fallback { 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::hash_types::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 ( - bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(a_nonref.data)), + bitcoin::hash_types::ScriptHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a_nonref.data)), ) }, } @@ -1858,18 +1928,19 @@ impl Fallback { }, Fallback::PubKeyHash (mut a, ) => { nativeFallback::PubKeyHash ( - bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(a.data)), + bitcoin::hash_types::PubkeyHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a.data)), ) }, Fallback::ScriptHash (mut a, ) => { nativeFallback::ScriptHash ( - bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(a.data)), + bitcoin::hash_types::ScriptHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(a.data)), ) }, } } #[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); @@ -1883,13 +1954,13 @@ impl Fallback { 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 ( - crate::c_types::TwentyBytes { data: a_nonref.as_hash().into_inner() }, + crate::c_types::TwentyBytes { data: *a_nonref.as_ref() }, ) }, } @@ -1906,12 +1977,12 @@ impl Fallback { }, 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 ( - crate::c_types::TwentyBytes { data: a.as_hash().into_inner() }, + crate::c_types::TwentyBytes { data: *a.as_ref() }, ) }, } @@ -1925,6 +1996,16 @@ pub extern "C" fn Fallback_free(this_ptr: Fallback) { } pub extern "C" fn Fallback_clone(orig: &Fallback) -> Fallback { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Fallback_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const Fallback)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Fallback_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut Fallback) }; +} #[no_mangle] /// Utility method to constructs a new SegWitProgram-variant Fallback pub extern "C" fn Fallback_seg_wit_program(version: crate::c_types::WitnessVersion, program: crate::c_types::derived::CVec_u8Z) -> Fallback { @@ -1943,6 +2024,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, ) } +/// 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 { @@ -1959,18 +2043,18 @@ pub extern "C" fn Fallback_eq(a: &Fallback, b: &Fallback) -> bool { if &a.to_native() == &b.to_native() { true } else { false } } -use lightning_invoice::InvoiceSignature as nativeInvoiceSignatureImport; -pub(crate) type nativeInvoiceSignature = nativeInvoiceSignatureImport; +use lightning_invoice::Bolt11InvoiceSignature as nativeBolt11InvoiceSignatureImport; +pub(crate) type nativeBolt11InvoiceSignature = nativeBolt11InvoiceSignatureImport; /// Recoverable signature #[must_use] #[repr(C)] -pub struct InvoiceSignature { +pub struct Bolt11InvoiceSignature { /// 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 nativeInvoiceSignature, + pub inner: *mut nativeBolt11InvoiceSignature, /// 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 @@ -1978,41 +2062,41 @@ pub struct InvoiceSignature { pub is_owned: bool, } -impl Drop for InvoiceSignature { +impl Drop for Bolt11InvoiceSignature { fn drop(&mut self) { - if self.is_owned && !<*mut nativeInvoiceSignature>::is_null(self.inner) { + if self.is_owned && !<*mut nativeBolt11InvoiceSignature>::is_null(self.inner) { let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; } } } -/// Frees any resources used by the InvoiceSignature, if is_owned is set and inner is non-NULL. +/// Frees any resources used by the Bolt11InvoiceSignature, if is_owned is set and inner is non-NULL. #[no_mangle] -pub extern "C" fn InvoiceSignature_free(this_obj: InvoiceSignature) { } +pub extern "C" fn Bolt11InvoiceSignature_free(this_obj: Bolt11InvoiceSignature) { } #[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) { - let _ = unsafe { Box::from_raw(this_ptr as *mut nativeInvoiceSignature) }; +pub(crate) extern "C" fn Bolt11InvoiceSignature_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeBolt11InvoiceSignature) }; } #[allow(unused)] -impl InvoiceSignature { - pub(crate) fn get_native_ref(&self) -> &'static nativeInvoiceSignature { +impl Bolt11InvoiceSignature { + pub(crate) fn get_native_ref(&self) -> &'static nativeBolt11InvoiceSignature { unsafe { &*ObjOps::untweak_ptr(self.inner) } } - pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeInvoiceSignature { + pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeBolt11InvoiceSignature { 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 nativeInvoiceSignature { + pub(crate) fn take_inner(mut self) -> *mut nativeBolt11InvoiceSignature { assert!(self.is_owned); let ret = ObjOps::untweak_ptr(self.inner); self.inner = core::ptr::null_mut(); ret } } -impl Clone for InvoiceSignature { +impl Clone for Bolt11InvoiceSignature { fn clone(&self) -> Self { Self { - inner: if <*mut nativeInvoiceSignature>::is_null(self.inner) { core::ptr::null_mut() } else { + inner: if <*mut nativeBolt11InvoiceSignature>::is_null(self.inner) { core::ptr::null_mut() } else { ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) }, is_owned: true, } @@ -2020,17 +2104,20 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInvoiceSignature)).clone() })) as *mut c_void +pub(crate) extern "C" fn Bolt11InvoiceSignature_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeBolt11InvoiceSignature)).clone() })) as *mut c_void } #[no_mangle] -/// Creates a copy of the InvoiceSignature -pub extern "C" fn InvoiceSignature_clone(orig: &InvoiceSignature) -> InvoiceSignature { +/// Creates a copy of the Bolt11InvoiceSignature +pub extern "C" fn Bolt11InvoiceSignature_clone(orig: &Bolt11InvoiceSignature) -> Bolt11InvoiceSignature { orig.clone() } -/// Generates a non-cryptographic 64-bit hash of the InvoiceSignature. +/// 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 InvoiceSignature_hash(o: &InvoiceSignature) -> u64 { +pub extern "C" fn Bolt11InvoiceSignature_hash(o: &Bolt11InvoiceSignature) -> 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)] @@ -2038,11 +2125,11 @@ pub extern "C" fn InvoiceSignature_hash(o: &InvoiceSignature) -> u64 { core::hash::Hash::hash(o.get_native_ref(), &mut hasher); core::hash::Hasher::finish(&hasher) } -/// Checks if two InvoiceSignatures contain equal inner contents. +/// Checks if two Bolt11InvoiceSignatures 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 InvoiceSignature_eq(a: &InvoiceSignature, b: &InvoiceSignature) -> bool { +pub extern "C" fn Bolt11InvoiceSignature_eq(a: &Bolt11InvoiceSignature, b: &Bolt11InvoiceSignature) -> 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 } @@ -2114,13 +2201,16 @@ impl Clone for 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_clone_void(this_ptr: *const c_void) -> *mut c_void { - Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePrivateRoute)).clone() })) as *mut c_void + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativePrivateRoute)).clone() })) as *mut c_void } #[no_mangle] /// Creates a copy of the PrivateRoute 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 { @@ -2140,30 +2230,30 @@ pub extern "C" fn PrivateRoute_eq(a: &PrivateRoute, b: &PrivateRoute) -> bool { if a.inner.is_null() || b.inner.is_null() { return false; } if a.get_native_ref() == b.get_native_ref() { true } else { false } } -/// Disassembles the `SignedRawInvoice` into its three parts: +/// Disassembles the `SignedRawBolt11Invoice` into its three parts: /// 1. raw invoice /// 2. hash of the raw invoice /// 3. signature #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_into_parts(mut this_arg: crate::lightning_invoice::SignedRawInvoice) -> crate::c_types::derived::C3Tuple_RawInvoice_u832InvoiceSignatureZ { +pub extern "C" fn SignedRawBolt11Invoice_into_parts(mut this_arg: crate::lightning_invoice::SignedRawBolt11Invoice) -> crate::c_types::derived::C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ { 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(); + let (mut orig_ret_0, mut orig_ret_1, mut orig_ret_2) = ret; let mut local_ret = (crate::lightning_invoice::RawBolt11Invoice { inner: ObjOps::heap_alloc(orig_ret_0), is_owned: true }, crate::c_types::ThirtyTwoBytes { data: orig_ret_1 }, crate::lightning_invoice::Bolt11InvoiceSignature { inner: ObjOps::heap_alloc(orig_ret_2), is_owned: true }).into(); local_ret } -/// The [`RawInvoice`] which was signed. +/// The [`RawBolt11Invoice`] which was signed. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_raw_invoice(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> crate::lightning_invoice::RawInvoice { +pub extern "C" fn SignedRawBolt11Invoice_raw_invoice(this_arg: &crate::lightning_invoice::SignedRawBolt11Invoice) -> crate::lightning_invoice::RawBolt11Invoice { 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 } + crate::lightning_invoice::RawBolt11Invoice { inner: unsafe { ObjOps::nonnull_ptr_to_inner((ret as *const lightning_invoice::RawBolt11Invoice<>) as *mut _) }, is_owned: false } } -/// The hash of the [`RawInvoice`] that was signed. +/// The hash of the [`RawBolt11Invoice`] that was signed. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_signable_hash(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> *const [u8; 32] { +pub extern "C" fn SignedRawBolt11Invoice_signable_hash(this_arg: &crate::lightning_invoice::SignedRawBolt11Invoice) -> *const [u8; 32] { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signable_hash(); ret } @@ -2171,15 +2261,15 @@ pub extern "C" fn SignedRawInvoice_signable_hash(this_arg: &crate::lightning_inv /// Signature for the invoice. #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_signature(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> crate::lightning_invoice::InvoiceSignature { +pub extern "C" fn SignedRawBolt11Invoice_signature(this_arg: &crate::lightning_invoice::SignedRawBolt11Invoice) -> crate::lightning_invoice::Bolt11InvoiceSignature { 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 } + crate::lightning_invoice::Bolt11InvoiceSignature { inner: unsafe { ObjOps::nonnull_ptr_to_inner((ret as *const lightning_invoice::Bolt11InvoiceSignature<>) as *mut _) }, is_owned: false } } /// 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: &crate::lightning_invoice::SignedRawInvoice) -> crate::c_types::derived::CResult_PayeePubKeyErrorZ { +pub extern "C" fn SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: &crate::lightning_invoice::SignedRawBolt11Invoice) -> crate::c_types::derived::CResult_PayeePubKeySecp256k1ErrorZ { 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 @@ -2189,15 +2279,15 @@ pub extern "C" fn SignedRawInvoice_recover_payee_pub_key(this_arg: &crate::light /// valid for the recovered signature (which should always be true?). #[must_use] #[no_mangle] -pub extern "C" fn SignedRawInvoice_check_signature(this_arg: &crate::lightning_invoice::SignedRawInvoice) -> bool { +pub extern "C" fn SignedRawBolt11Invoice_check_signature(this_arg: &crate::lightning_invoice::SignedRawBolt11Invoice) -> bool { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.check_signature(); ret } -/// Calculate the hash of the encoded `RawInvoice` which should be signed. +/// Calculate the hash of the encoded `RawBolt11Invoice` which should be signed. #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_signable_hash(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::ThirtyTwoBytes { +pub extern "C" fn RawBolt11Invoice_signable_hash(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::c_types::ThirtyTwoBytes { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signable_hash(); crate::c_types::ThirtyTwoBytes { data: ret } } @@ -2206,7 +2296,7 @@ pub extern "C" fn RawInvoice_signable_hash(this_arg: &crate::lightning_invoice:: /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_payment_hash(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Sha256 { +pub extern "C" fn RawBolt11Invoice_payment_hash(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 @@ -2216,7 +2306,7 @@ pub extern "C" fn RawInvoice_payment_hash(this_arg: &crate::lightning_invoice::R /// 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: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Description { +pub extern "C" fn RawBolt11Invoice_description(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 @@ -2226,7 +2316,7 @@ pub extern "C" fn RawInvoice_description(this_arg: &crate::lightning_invoice::Ra /// 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: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::PayeePubKey { +pub extern "C" fn RawBolt11Invoice_payee_pub_key(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 @@ -2236,7 +2326,7 @@ pub extern "C" fn RawInvoice_payee_pub_key(this_arg: &crate::lightning_invoice:: /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_description_hash(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Sha256 { +pub extern "C" fn RawBolt11Invoice_description_hash(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 @@ -2246,7 +2336,7 @@ pub extern "C" fn RawInvoice_description_hash(this_arg: &crate::lightning_invoic /// 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: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::ExpiryTime { +pub extern "C" fn RawBolt11Invoice_expiry_time(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 @@ -2256,25 +2346,23 @@ pub extern "C" fn RawInvoice_expiry_time(this_arg: &crate::lightning_invoice::Ra /// 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_delta(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::MinFinalCltvExpiryDelta { +pub extern "C" fn RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 } -/// -/// 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: &crate::lightning_invoice::RawInvoice) -> crate::c_types::ThirtyTwoBytes { +pub extern "C" fn RawBolt11Invoice_payment_secret(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::c_types::derived::COption_ThirtyTwoBytesZ { 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 } } }; + let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */ { crate::c_types::ThirtyTwoBytes { data: (*ret.as_ref().unwrap()).clone().0 } }) }; local_ret } #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_payment_metadata(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::derived::COption_CVec_u8ZZ { +pub extern "C" fn RawBolt11Invoice_payment_metadata(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::c_types::derived::COption_CVec_u8ZZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_metadata(); let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */ { let mut local_ret_0 = Vec::new(); for mut item in (*ret.as_ref().unwrap()).clone().drain(..) { local_ret_0.push( { item }); }; local_ret_0.into() }) }; local_ret @@ -2284,23 +2372,24 @@ pub extern "C" fn RawInvoice_payment_metadata(this_arg: &crate::lightning_invoic /// 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: &crate::lightning_invoice::RawInvoice) -> crate::lightning::ln::features::InvoiceFeatures { +pub extern "C" fn RawBolt11Invoice_features(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::lightning::ln::features::Bolt11InvoiceFeatures { 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 }; + 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 }; local_ret } #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_private_routes(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::derived::CVec_PrivateRouteZ { +pub extern "C" fn RawBolt11Invoice_private_routes(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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() } +/// Returns `None` if no amount is set or on overflow. #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_amount_pico_btc(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::c_types::derived::COption_u64Z { +pub extern "C" fn RawBolt11Invoice_amount_pico_btc(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> 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 @@ -2308,7 +2397,7 @@ pub extern "C" fn RawInvoice_amount_pico_btc(this_arg: &crate::lightning_invoice #[must_use] #[no_mangle] -pub extern "C" fn RawInvoice_currency(this_arg: &crate::lightning_invoice::RawInvoice) -> crate::lightning_invoice::Currency { +pub extern "C" fn RawBolt11Invoice_currency(this_arg: &crate::lightning_invoice::RawBolt11Invoice) -> crate::lightning_invoice::Currency { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.currency(); crate::lightning_invoice::Currency::native_into(ret) } @@ -2376,32 +2465,32 @@ pub extern "C" fn PositiveTimestamp_as_time(this_arg: &crate::lightning_invoice: ret.duration_since(::std::time::SystemTime::UNIX_EPOCH).expect("Times must be post-1970").as_secs() } -/// The hash of the [`RawInvoice`] that was signed. +/// The hash of the [`RawBolt11Invoice`] that was signed. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_signable_hash(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::ThirtyTwoBytes { +pub extern "C" fn Bolt11Invoice_signable_hash(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::ThirtyTwoBytes { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.signable_hash(); crate::c_types::ThirtyTwoBytes { data: ret } } -/// Transform the `Invoice` into it's unchecked version +/// Transform the `Bolt11Invoice` into its unchecked version. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_into_signed_raw(mut this_arg: crate::lightning_invoice::Invoice) -> crate::lightning_invoice::SignedRawInvoice { +pub extern "C" fn Bolt11Invoice_into_signed_raw(mut this_arg: crate::lightning_invoice::Bolt11Invoice) -> crate::lightning_invoice::SignedRawBolt11Invoice { 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 } + crate::lightning_invoice::SignedRawBolt11Invoice { inner: ObjOps::heap_alloc(ret), is_owned: true } } /// 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: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CResult_NoneSemanticErrorZ { +pub extern "C" fn Bolt11Invoice_check_signature(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::derived::CResult_NoneBolt11SemanticErrorZ { 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() }; + 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::Bolt11SemanticError::native_into(e) }).into() }; local_ret } -/// Constructs an `Invoice` from a [`SignedRawInvoice`] by checking all its invariants. +/// Constructs a `Bolt11Invoice` from a [`SignedRawBolt11Invoice`] by checking all its invariants. /// ``` /// use lightning_invoice::*; /// @@ -2417,30 +2506,30 @@ pub extern "C" fn Invoice_check_signature(this_arg: &crate::lightning_invoice::I /// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\\ /// j5r6drg6k6zcqj0fcwg\"; /// -/// let signed = invoice.parse::().unwrap(); +/// let signed = invoice.parse::().unwrap(); /// -/// assert!(Invoice::from_signed(signed).is_ok()); +/// assert!(Bolt11Invoice::from_signed(signed).is_ok()); /// ``` #[must_use] #[no_mangle] -pub extern "C" fn Invoice_from_signed(mut signed_invoice: crate::lightning_invoice::SignedRawInvoice) -> crate::c_types::derived::CResult_InvoiceSemanticErrorZ { - let mut ret = lightning_invoice::Invoice::from_signed(*unsafe { Box::from_raw(signed_invoice.take_inner()) }); - let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SemanticError::native_into(e) }).into() }; +pub extern "C" fn Bolt11Invoice_from_signed(mut signed_invoice: crate::lightning_invoice::SignedRawBolt11Invoice) -> crate::c_types::derived::CResult_Bolt11InvoiceBolt11SemanticErrorZ { + let mut ret = lightning_invoice::Bolt11Invoice::from_signed(*unsafe { Box::from_raw(signed_invoice.take_inner()) }); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Bolt11Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::Bolt11SemanticError::native_into(e) }).into() }; local_ret } -/// Returns the `Invoice`'s timestamp (should equal its creation time) +/// Returns the `Bolt11Invoice`'s timestamp (should equal its creation time) #[must_use] #[no_mangle] -pub extern "C" fn Invoice_timestamp(this_arg: &crate::lightning_invoice::Invoice) -> u64 { +pub extern "C" fn Bolt11Invoice_timestamp(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> 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() } -/// Returns the `Invoice`'s timestamp as a duration since the Unix epoch +/// Returns the `Bolt11Invoice`'s timestamp as a duration since the Unix epoch #[must_use] #[no_mangle] -pub extern "C" fn Invoice_duration_since_epoch(this_arg: &crate::lightning_invoice::Invoice) -> u64 { +pub extern "C" fn Bolt11Invoice_duration_since_epoch(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.duration_since_epoch(); ret.as_secs() } @@ -2448,9 +2537,9 @@ pub extern "C" fn Invoice_duration_since_epoch(this_arg: &crate::lightning_invoi /// 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: &crate::lightning_invoice::Invoice) -> *const [u8; 32] { +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 @@ -2458,7 +2547,7 @@ pub extern "C" fn Invoice_payment_hash(this_arg: &crate::lightning_invoice::Invo /// 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: &crate::lightning_invoice::Invoice) -> crate::c_types::PublicKey { +pub extern "C" fn Bolt11Invoice_payee_pub_key(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> 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 @@ -2467,7 +2556,7 @@ pub extern "C" fn Invoice_payee_pub_key(this_arg: &crate::lightning_invoice::Inv /// Get the payment secret if one was included in the invoice #[must_use] #[no_mangle] -pub extern "C" fn Invoice_payment_secret(this_arg: &crate::lightning_invoice::Invoice) -> *const [u8; 32] { +pub extern "C" fn Bolt11Invoice_payment_secret(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> *const [u8; 32] { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_secret(); &ret.0 } @@ -2475,7 +2564,7 @@ pub extern "C" fn Invoice_payment_secret(this_arg: &crate::lightning_invoice::In /// Get the payment metadata blob if one was included in the invoice #[must_use] #[no_mangle] -pub extern "C" fn Invoice_payment_metadata(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::COption_CVec_u8ZZ { +pub extern "C" fn Bolt11Invoice_payment_metadata(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::derived::COption_CVec_u8ZZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.payment_metadata(); let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */ { let mut local_ret_0 = Vec::new(); for mut item in (*ret.as_ref().unwrap()).clone().drain(..) { local_ret_0.push( { item }); }; local_ret_0.into() }) }; local_ret @@ -2486,34 +2575,43 @@ pub extern "C" fn Invoice_payment_metadata(this_arg: &crate::lightning_invoice:: /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None #[must_use] #[no_mangle] -pub extern "C" fn Invoice_features(this_arg: &crate::lightning_invoice::Invoice) -> crate::lightning::ln::features::InvoiceFeatures { +pub extern "C" fn Bolt11Invoice_features(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::lightning::ln::features::Bolt11InvoiceFeatures { 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 }; + 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 }; local_ret } /// 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: &crate::lightning_invoice::Invoice) -> crate::c_types::PublicKey { +pub extern "C" fn Bolt11Invoice_recover_payee_pub_key(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> 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) } +/// 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] #[no_mangle] -pub extern "C" fn Invoice_expires_at(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::COption_DurationZ { +pub extern "C" fn Bolt11Invoice_expires_at(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::derived::COption_u64Z { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expires_at(); - let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_DurationZ::None } else { crate::c_types::derived::COption_DurationZ::Some( { ret.unwrap().as_secs() }) }; + 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().as_secs() }) }; local_ret } /// Returns the invoice's expiry time, if present, otherwise [`DEFAULT_EXPIRY_TIME`]. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_expiry_time(this_arg: &crate::lightning_invoice::Invoice) -> u64 { +pub extern "C" fn Bolt11Invoice_expiry_time(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expiry_time(); ret.as_secs() } @@ -2521,7 +2619,7 @@ pub extern "C" fn Invoice_expiry_time(this_arg: &crate::lightning_invoice::Invoi /// Returns whether the invoice has expired. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_is_expired(this_arg: &crate::lightning_invoice::Invoice) -> bool { +pub extern "C" fn Bolt11Invoice_is_expired(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> bool { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.is_expired(); ret } @@ -2529,7 +2627,7 @@ pub extern "C" fn Invoice_is_expired(this_arg: &crate::lightning_invoice::Invoic /// Returns the Duration remaining until the invoice expires. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_duration_until_expiry(this_arg: &crate::lightning_invoice::Invoice) -> u64 { +pub extern "C" fn Bolt11Invoice_duration_until_expiry(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.duration_until_expiry(); ret.as_secs() } @@ -2538,7 +2636,7 @@ pub extern "C" fn Invoice_duration_until_expiry(this_arg: &crate::lightning_invo /// `time` is the timestamp as a duration since the Unix epoch. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_expiration_remaining_from_epoch(this_arg: &crate::lightning_invoice::Invoice, mut time: u64) -> u64 { +pub extern "C" fn Bolt11Invoice_expiration_remaining_from_epoch(this_arg: &crate::lightning_invoice::Bolt11Invoice, mut time: u64) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.expiration_remaining_from_epoch(core::time::Duration::from_secs(time)); ret.as_secs() } @@ -2547,7 +2645,7 @@ pub extern "C" fn Invoice_expiration_remaining_from_epoch(this_arg: &crate::ligh /// `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: &crate::lightning_invoice::Invoice, mut at_time: u64) -> bool { +pub extern "C" fn Bolt11Invoice_would_expire(this_arg: &crate::lightning_invoice::Bolt11Invoice, 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 } @@ -2556,7 +2654,7 @@ pub extern "C" fn Invoice_would_expire(this_arg: &crate::lightning_invoice::Invo /// [`DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA`]. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_min_final_cltv_expiry_delta(this_arg: &crate::lightning_invoice::Invoice) -> u64 { +pub extern "C" fn Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> u64 { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.min_final_cltv_expiry_delta(); ret } @@ -2564,7 +2662,7 @@ pub extern "C" fn Invoice_min_final_cltv_expiry_delta(this_arg: &crate::lightnin /// Returns a list of all fallback addresses as [`Address`]es #[must_use] #[no_mangle] -pub extern "C" fn Invoice_fallback_addresses(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CVec_AddressZ { +pub extern "C" fn Bolt11Invoice_fallback_addresses(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::c_types::derived::CVec_StrZ { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.fallback_addresses(); let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { alloc::string::ToString::to_string(&item).into() }); }; local_ret.into() @@ -2573,7 +2671,7 @@ pub extern "C" fn Invoice_fallback_addresses(this_arg: &crate::lightning_invoice /// Returns a list of all routes included in the invoice #[must_use] #[no_mangle] -pub extern "C" fn Invoice_private_routes(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CVec_PrivateRouteZ { +pub extern "C" fn Bolt11Invoice_private_routes(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> 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() @@ -2582,7 +2680,7 @@ pub extern "C" fn Invoice_private_routes(this_arg: &crate::lightning_invoice::In /// 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: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::CVec_RouteHintZ { +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 } }); }; local_ret.into() @@ -2591,7 +2689,7 @@ pub extern "C" fn Invoice_route_hints(this_arg: &crate::lightning_invoice::Invoi /// Returns the currency for which the invoice was issued #[must_use] #[no_mangle] -pub extern "C" fn Invoice_currency(this_arg: &crate::lightning_invoice::Invoice) -> crate::lightning_invoice::Currency { +pub extern "C" fn Bolt11Invoice_currency(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> crate::lightning_invoice::Currency { let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.currency(); crate::lightning_invoice::Currency::native_into(ret) } @@ -2599,7 +2697,7 @@ pub extern "C" fn Invoice_currency(this_arg: &crate::lightning_invoice::Invoice) /// Returns the amount if specified in the invoice as millisatoshis. #[must_use] #[no_mangle] -pub extern "C" fn Invoice_amount_milli_satoshis(this_arg: &crate::lightning_invoice::Invoice) -> crate::c_types::derived::COption_u64Z { +pub extern "C" fn Bolt11Invoice_amount_milli_satoshis(this_arg: &crate::lightning_invoice::Bolt11Invoice) -> 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 @@ -2617,14 +2715,19 @@ pub extern "C" fn Description_new(mut description: crate::c_types::Str) -> crate local_ret } -/// Returns the underlying description [`String`] +/// Returns the underlying description [`UntrustedString`] #[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::util::string::UntrustedString { let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).into_inner(); - ret.into() + crate::lightning::util::string::UntrustedString { inner: ObjOps::heap_alloc(ret), is_owned: true } } +#[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] @@ -2674,7 +2777,7 @@ pub extern "C" fn PrivateRoute_into_inner(mut this_arg: crate::lightning_invoice crate::lightning::routing::router::RouteHint { inner: ObjOps::heap_alloc(ret), is_owned: true } } -/// Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`] +/// Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`] #[derive(Clone)] #[must_use] #[repr(C)] @@ -2724,7 +2827,8 @@ impl CreationError { } } #[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, @@ -2751,6 +2855,16 @@ impl CreationError { pub extern "C" fn CreationError_clone(orig: &CreationError) -> CreationError { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn CreationError_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const CreationError)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn CreationError_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut CreationError) }; +} #[no_mangle] /// Utility method to constructs a new DescriptionTooLong-variant CreationError pub extern "C" fn CreationError_description_too_long() -> CreationError { @@ -2781,17 +2895,20 @@ 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 } } +/// 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 { alloc::format!("{}", &o.to_native()).into() } -/// Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`]. They relate to the -/// requirements sections in BOLT #11 +/// Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to +/// the requirements sections in BOLT #11 #[derive(Clone)] #[must_use] #[repr(C)] -pub enum SemanticError { +pub enum Bolt11SemanticError { /// The invoice is missing the mandatory payment hash NoPaymentHash, /// The invoice has multiple payment hashes which isn't allowed @@ -2814,125 +2931,139 @@ pub enum SemanticError { /// The invoice's amount was not a whole number of millisatoshis ImpreciseAmount, } -use lightning_invoice::SemanticError as SemanticErrorImport; -pub(crate) type nativeSemanticError = SemanticErrorImport; +use lightning_invoice::Bolt11SemanticError as Bolt11SemanticErrorImport; +pub(crate) type nativeBolt11SemanticError = Bolt11SemanticErrorImport; -impl SemanticError { +impl Bolt11SemanticError { #[allow(unused)] - pub(crate) fn to_native(&self) -> nativeSemanticError { + pub(crate) fn to_native(&self) -> nativeBolt11SemanticError { match self { - SemanticError::NoPaymentHash => nativeSemanticError::NoPaymentHash, - SemanticError::MultiplePaymentHashes => nativeSemanticError::MultiplePaymentHashes, - SemanticError::NoDescription => nativeSemanticError::NoDescription, - SemanticError::MultipleDescriptions => nativeSemanticError::MultipleDescriptions, - SemanticError::NoPaymentSecret => nativeSemanticError::NoPaymentSecret, - SemanticError::MultiplePaymentSecrets => nativeSemanticError::MultiplePaymentSecrets, - SemanticError::InvalidFeatures => nativeSemanticError::InvalidFeatures, - SemanticError::InvalidRecoveryId => nativeSemanticError::InvalidRecoveryId, - SemanticError::InvalidSignature => nativeSemanticError::InvalidSignature, - SemanticError::ImpreciseAmount => nativeSemanticError::ImpreciseAmount, + Bolt11SemanticError::NoPaymentHash => nativeBolt11SemanticError::NoPaymentHash, + Bolt11SemanticError::MultiplePaymentHashes => nativeBolt11SemanticError::MultiplePaymentHashes, + Bolt11SemanticError::NoDescription => nativeBolt11SemanticError::NoDescription, + Bolt11SemanticError::MultipleDescriptions => nativeBolt11SemanticError::MultipleDescriptions, + Bolt11SemanticError::NoPaymentSecret => nativeBolt11SemanticError::NoPaymentSecret, + Bolt11SemanticError::MultiplePaymentSecrets => nativeBolt11SemanticError::MultiplePaymentSecrets, + Bolt11SemanticError::InvalidFeatures => nativeBolt11SemanticError::InvalidFeatures, + Bolt11SemanticError::InvalidRecoveryId => nativeBolt11SemanticError::InvalidRecoveryId, + Bolt11SemanticError::InvalidSignature => nativeBolt11SemanticError::InvalidSignature, + Bolt11SemanticError::ImpreciseAmount => nativeBolt11SemanticError::ImpreciseAmount, } } #[allow(unused)] - pub(crate) fn into_native(self) -> nativeSemanticError { + pub(crate) fn into_native(self) -> nativeBolt11SemanticError { match self { - SemanticError::NoPaymentHash => nativeSemanticError::NoPaymentHash, - SemanticError::MultiplePaymentHashes => nativeSemanticError::MultiplePaymentHashes, - SemanticError::NoDescription => nativeSemanticError::NoDescription, - SemanticError::MultipleDescriptions => nativeSemanticError::MultipleDescriptions, - SemanticError::NoPaymentSecret => nativeSemanticError::NoPaymentSecret, - SemanticError::MultiplePaymentSecrets => nativeSemanticError::MultiplePaymentSecrets, - SemanticError::InvalidFeatures => nativeSemanticError::InvalidFeatures, - SemanticError::InvalidRecoveryId => nativeSemanticError::InvalidRecoveryId, - SemanticError::InvalidSignature => nativeSemanticError::InvalidSignature, - SemanticError::ImpreciseAmount => nativeSemanticError::ImpreciseAmount, + Bolt11SemanticError::NoPaymentHash => nativeBolt11SemanticError::NoPaymentHash, + Bolt11SemanticError::MultiplePaymentHashes => nativeBolt11SemanticError::MultiplePaymentHashes, + Bolt11SemanticError::NoDescription => nativeBolt11SemanticError::NoDescription, + Bolt11SemanticError::MultipleDescriptions => nativeBolt11SemanticError::MultipleDescriptions, + Bolt11SemanticError::NoPaymentSecret => nativeBolt11SemanticError::NoPaymentSecret, + Bolt11SemanticError::MultiplePaymentSecrets => nativeBolt11SemanticError::MultiplePaymentSecrets, + Bolt11SemanticError::InvalidFeatures => nativeBolt11SemanticError::InvalidFeatures, + Bolt11SemanticError::InvalidRecoveryId => nativeBolt11SemanticError::InvalidRecoveryId, + Bolt11SemanticError::InvalidSignature => nativeBolt11SemanticError::InvalidSignature, + Bolt11SemanticError::ImpreciseAmount => nativeBolt11SemanticError::ImpreciseAmount, } } #[allow(unused)] - pub(crate) fn from_native(native: &nativeSemanticError) -> Self { + pub(crate) fn from_native(native: &Bolt11SemanticErrorImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativeBolt11SemanticError) }; match native { - nativeSemanticError::NoPaymentHash => SemanticError::NoPaymentHash, - nativeSemanticError::MultiplePaymentHashes => SemanticError::MultiplePaymentHashes, - nativeSemanticError::NoDescription => SemanticError::NoDescription, - nativeSemanticError::MultipleDescriptions => SemanticError::MultipleDescriptions, - nativeSemanticError::NoPaymentSecret => SemanticError::NoPaymentSecret, - nativeSemanticError::MultiplePaymentSecrets => SemanticError::MultiplePaymentSecrets, - nativeSemanticError::InvalidFeatures => SemanticError::InvalidFeatures, - nativeSemanticError::InvalidRecoveryId => SemanticError::InvalidRecoveryId, - nativeSemanticError::InvalidSignature => SemanticError::InvalidSignature, - nativeSemanticError::ImpreciseAmount => SemanticError::ImpreciseAmount, + nativeBolt11SemanticError::NoPaymentHash => Bolt11SemanticError::NoPaymentHash, + nativeBolt11SemanticError::MultiplePaymentHashes => Bolt11SemanticError::MultiplePaymentHashes, + nativeBolt11SemanticError::NoDescription => Bolt11SemanticError::NoDescription, + nativeBolt11SemanticError::MultipleDescriptions => Bolt11SemanticError::MultipleDescriptions, + nativeBolt11SemanticError::NoPaymentSecret => Bolt11SemanticError::NoPaymentSecret, + nativeBolt11SemanticError::MultiplePaymentSecrets => Bolt11SemanticError::MultiplePaymentSecrets, + nativeBolt11SemanticError::InvalidFeatures => Bolt11SemanticError::InvalidFeatures, + nativeBolt11SemanticError::InvalidRecoveryId => Bolt11SemanticError::InvalidRecoveryId, + nativeBolt11SemanticError::InvalidSignature => Bolt11SemanticError::InvalidSignature, + nativeBolt11SemanticError::ImpreciseAmount => Bolt11SemanticError::ImpreciseAmount, } } #[allow(unused)] - pub(crate) fn native_into(native: nativeSemanticError) -> Self { + pub(crate) fn native_into(native: nativeBolt11SemanticError) -> Self { match native { - nativeSemanticError::NoPaymentHash => SemanticError::NoPaymentHash, - nativeSemanticError::MultiplePaymentHashes => SemanticError::MultiplePaymentHashes, - nativeSemanticError::NoDescription => SemanticError::NoDescription, - nativeSemanticError::MultipleDescriptions => SemanticError::MultipleDescriptions, - nativeSemanticError::NoPaymentSecret => SemanticError::NoPaymentSecret, - nativeSemanticError::MultiplePaymentSecrets => SemanticError::MultiplePaymentSecrets, - nativeSemanticError::InvalidFeatures => SemanticError::InvalidFeatures, - nativeSemanticError::InvalidRecoveryId => SemanticError::InvalidRecoveryId, - nativeSemanticError::InvalidSignature => SemanticError::InvalidSignature, - nativeSemanticError::ImpreciseAmount => SemanticError::ImpreciseAmount, + nativeBolt11SemanticError::NoPaymentHash => Bolt11SemanticError::NoPaymentHash, + nativeBolt11SemanticError::MultiplePaymentHashes => Bolt11SemanticError::MultiplePaymentHashes, + nativeBolt11SemanticError::NoDescription => Bolt11SemanticError::NoDescription, + nativeBolt11SemanticError::MultipleDescriptions => Bolt11SemanticError::MultipleDescriptions, + nativeBolt11SemanticError::NoPaymentSecret => Bolt11SemanticError::NoPaymentSecret, + nativeBolt11SemanticError::MultiplePaymentSecrets => Bolt11SemanticError::MultiplePaymentSecrets, + nativeBolt11SemanticError::InvalidFeatures => Bolt11SemanticError::InvalidFeatures, + nativeBolt11SemanticError::InvalidRecoveryId => Bolt11SemanticError::InvalidRecoveryId, + nativeBolt11SemanticError::InvalidSignature => Bolt11SemanticError::InvalidSignature, + nativeBolt11SemanticError::ImpreciseAmount => Bolt11SemanticError::ImpreciseAmount, } } } -/// Creates a copy of the SemanticError +/// Creates a copy of the Bolt11SemanticError #[no_mangle] -pub extern "C" fn SemanticError_clone(orig: &SemanticError) -> SemanticError { +pub extern "C" fn Bolt11SemanticError_clone(orig: &Bolt11SemanticError) -> Bolt11SemanticError { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Bolt11SemanticError_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const Bolt11SemanticError)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Bolt11SemanticError_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut Bolt11SemanticError) }; +} #[no_mangle] -/// Utility method to constructs a new NoPaymentHash-variant SemanticError -pub extern "C" fn SemanticError_no_payment_hash() -> SemanticError { - SemanticError::NoPaymentHash} +/// Utility method to constructs a new NoPaymentHash-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_no_payment_hash() -> Bolt11SemanticError { + Bolt11SemanticError::NoPaymentHash} #[no_mangle] -/// Utility method to constructs a new MultiplePaymentHashes-variant SemanticError -pub extern "C" fn SemanticError_multiple_payment_hashes() -> SemanticError { - SemanticError::MultiplePaymentHashes} +/// Utility method to constructs a new MultiplePaymentHashes-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_multiple_payment_hashes() -> Bolt11SemanticError { + Bolt11SemanticError::MultiplePaymentHashes} #[no_mangle] -/// Utility method to constructs a new NoDescription-variant SemanticError -pub extern "C" fn SemanticError_no_description() -> SemanticError { - SemanticError::NoDescription} +/// Utility method to constructs a new NoDescription-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_no_description() -> Bolt11SemanticError { + Bolt11SemanticError::NoDescription} #[no_mangle] -/// Utility method to constructs a new MultipleDescriptions-variant SemanticError -pub extern "C" fn SemanticError_multiple_descriptions() -> SemanticError { - SemanticError::MultipleDescriptions} +/// Utility method to constructs a new MultipleDescriptions-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_multiple_descriptions() -> Bolt11SemanticError { + Bolt11SemanticError::MultipleDescriptions} #[no_mangle] -/// Utility method to constructs a new NoPaymentSecret-variant SemanticError -pub extern "C" fn SemanticError_no_payment_secret() -> SemanticError { - SemanticError::NoPaymentSecret} +/// Utility method to constructs a new NoPaymentSecret-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_no_payment_secret() -> Bolt11SemanticError { + Bolt11SemanticError::NoPaymentSecret} #[no_mangle] -/// Utility method to constructs a new MultiplePaymentSecrets-variant SemanticError -pub extern "C" fn SemanticError_multiple_payment_secrets() -> SemanticError { - SemanticError::MultiplePaymentSecrets} +/// Utility method to constructs a new MultiplePaymentSecrets-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_multiple_payment_secrets() -> Bolt11SemanticError { + Bolt11SemanticError::MultiplePaymentSecrets} #[no_mangle] -/// Utility method to constructs a new InvalidFeatures-variant SemanticError -pub extern "C" fn SemanticError_invalid_features() -> SemanticError { - SemanticError::InvalidFeatures} +/// Utility method to constructs a new InvalidFeatures-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_invalid_features() -> Bolt11SemanticError { + Bolt11SemanticError::InvalidFeatures} #[no_mangle] -/// Utility method to constructs a new InvalidRecoveryId-variant SemanticError -pub extern "C" fn SemanticError_invalid_recovery_id() -> SemanticError { - SemanticError::InvalidRecoveryId} +/// Utility method to constructs a new InvalidRecoveryId-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_invalid_recovery_id() -> Bolt11SemanticError { + Bolt11SemanticError::InvalidRecoveryId} #[no_mangle] -/// Utility method to constructs a new InvalidSignature-variant SemanticError -pub extern "C" fn SemanticError_invalid_signature() -> SemanticError { - SemanticError::InvalidSignature} +/// Utility method to constructs a new InvalidSignature-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_invalid_signature() -> Bolt11SemanticError { + Bolt11SemanticError::InvalidSignature} #[no_mangle] -/// Utility method to constructs a new ImpreciseAmount-variant SemanticError -pub extern "C" fn SemanticError_imprecise_amount() -> SemanticError { - SemanticError::ImpreciseAmount} -/// Checks if two SemanticErrors contain equal inner contents. +/// Utility method to constructs a new ImpreciseAmount-variant Bolt11SemanticError +pub extern "C" fn Bolt11SemanticError_imprecise_amount() -> Bolt11SemanticError { + Bolt11SemanticError::ImpreciseAmount} +/// Checks if two Bolt11SemanticErrors contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] -pub extern "C" fn SemanticError_eq(a: &SemanticError, b: &SemanticError) -> bool { +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 SemanticError object -pub extern "C" fn SemanticError_to_str(o: &crate::lightning_invoice::SemanticError) -> Str { +/// Get the string representation of a Bolt11SemanticError object +pub extern "C" fn Bolt11SemanticError_to_str(o: &crate::lightning_invoice::Bolt11SemanticError) -> Str { alloc::format!("{}", &o.to_native()).into() } /// When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`] @@ -2983,7 +3114,8 @@ impl SignOrCreationError { } } #[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 }, @@ -3016,6 +3148,16 @@ pub extern "C" fn SignOrCreationError_free(this_ptr: SignOrCreationError) { } pub extern "C" fn SignOrCreationError_clone(orig: &SignOrCreationError) -> SignOrCreationError { orig.clone() } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn SignOrCreationError_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const SignOrCreationError)).clone() })) as *mut c_void +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn SignOrCreationError_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut SignOrCreationError) }; +} #[no_mangle] /// Utility method to constructs a new SignError-variant SignOrCreationError pub extern "C" fn SignOrCreationError_sign_error() -> SignOrCreationError { @@ -3032,6 +3174,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 } } +/// 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 {