Update hardcoded and manually-defined types for LDK 0.0.117

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 007a05b1fc8a4e4e97389cc6871a250248680f1a..1cb7420e7d8c8686c73fed2038fc6fb69113459b 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -863,7 +863,8 @@ fn initial_clonable_types() -> HashSet<String> {
        res.insert("crate::c_types::WitnessVersion".to_owned());
        res.insert("crate::c_types::TxIn".to_owned());
        res.insert("crate::c_types::TxOut".to_owned());
-       res.insert("crate::c_types::Signature".to_owned());
+       res.insert("crate::c_types::ECDSASignature".to_owned());
+       res.insert("crate::c_types::SchnorrSignature".to_owned());
        res.insert("crate::c_types::RecoverableSignature".to_owned());
        res.insert("crate::c_types::BigEndianScalar".to_owned());
        res.insert("crate::c_types::Bech32Error".to_owned());
@@ -1030,10 +1031,10 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "[u8; 12]" if !is_ref => Some("crate::c_types::TwelveBytes"),
                        "[u8; 4]" if !is_ref => Some("crate::c_types::FourBytes"),
                        "[u8; 3]" if !is_ref => Some("crate::c_types::ThreeBytes"), // Used for RGB values
-                       "[u16; 8]" if !is_ref => Some("crate::c_types::EightU16s"),
+                       "[u16; 32]" if !is_ref => Some("crate::c_types::ThirtyTwoU16s"),
 
                        "str" if is_ref => Some("crate::c_types::Str"),
-                       "alloc::string::String"|"String" => Some("crate::c_types::Str"),
+                       "alloc::string::String"|"String"|"std::path::PathBuf" => Some("crate::c_types::Str"),
 
                        "bitcoin::Address" => Some("crate::c_types::Str"),
 
@@ -1057,7 +1058,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "core::num::NonZeroU8" => Some("u8"),
 
                        "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => Some("crate::c_types::PublicKey"),
-                       "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::Signature"),
+                       "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::ECDSASignature"),
+                       "bitcoin::secp256k1::schnorr::Signature" => Some("crate::c_types::SchnorrSignature"),
                        "bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some("crate::c_types::RecoverableSignature"),
                        "bitcoin::secp256k1::SecretKey" if is_ref  => Some("*const [u8; 32]"),
                        "bitcoin::secp256k1::SecretKey" if !is_ref => Some("crate::c_types::SecretKey"),
@@ -1102,10 +1104,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if is_ref => Some("*const [u8; 32]"),
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if !is_ref => Some("crate::c_types::ThirtyTwoBytes"),
 
                        "lightning::io::Read" => Some("crate::c_types::u8slice"),
@@ -1134,13 +1138,13 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "[u8; 12]" if !is_ref => Some(""),
                        "[u8; 4]" if !is_ref => Some(""),
                        "[u8; 3]" if !is_ref => Some(""),
-                       "[u16; 8]" if !is_ref => Some(""),
+                       "[u16; 32]" if !is_ref => Some(""),
 
                        "[u8]" if is_ref => Some(""),
                        "[usize]" if is_ref => Some(""),
 
                        "str" if is_ref => Some(""),
-                       "alloc::string::String"|"String" => Some(""),
+                       "alloc::string::String"|"String"|"std::path::PathBuf" => Some(""),
                        "std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some(""),
                        // Note that we'll panic for String if is_ref, as we only have non-owned memory, we
                        // cannot create a &String.
@@ -1162,12 +1166,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
                        "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" if is_ref => Some("&"),
                        "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(""),
-                       "bitcoin::secp256k1::ecdsa::Signature" if is_ref => Some("&"),
-                       "bitcoin::secp256k1::ecdsa::Signature" => Some(""),
+                       "bitcoin::secp256k1::ecdsa::Signature"|"bitcoin::secp256k1::schnorr::Signature" if is_ref => Some("&"),
+                       "bitcoin::secp256k1::ecdsa::Signature"|"bitcoin::secp256k1::schnorr::Signature" => Some(""),
                        "bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some(""),
                        "bitcoin::secp256k1::SecretKey" if is_ref => Some("&::bitcoin::secp256k1::SecretKey::from_slice(&unsafe { *"),
                        "bitcoin::secp256k1::SecretKey" if !is_ref => Some(""),
-                       "bitcoin::secp256k1::KeyPair" if !is_ref => Some("::bitcoin::secp256k1::KeyPair::new("),
+                       "bitcoin::secp256k1::KeyPair" if !is_ref => Some("::bitcoin::secp256k1::KeyPair::from_secret_key(&secp256k1::global::SECP256K1, &"),
                        "bitcoin::secp256k1::Scalar" if is_ref => Some("&"),
                        "bitcoin::secp256k1::Scalar" if !is_ref => Some(""),
                        "bitcoin::secp256k1::ecdh::SharedSecret" if !is_ref => Some("::bitcoin::secp256k1::ecdh::SharedSecret::from_bytes("),
@@ -1217,6 +1221,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "lightning::ln::channelmanager::PaymentId" if is_ref=> Some("&::lightning::ln::channelmanager::PaymentId( unsafe { *"),
                        "lightning::ln::channelmanager::InterceptId" if !is_ref => Some("::lightning::ln::channelmanager::InterceptId("),
                        "lightning::ln::channelmanager::InterceptId" if is_ref=> Some("&::lightning::ln::channelmanager::InterceptId( unsafe { *"),
+                       "lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId" if !is_ref => Some("::lightning::ln::ChannelId("),
+                       "lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId" if is_ref => Some("&::lightning::ln::ChannelId(unsafe { *"),
                        "lightning::sign::KeyMaterial" if !is_ref => Some("::lightning::sign::KeyMaterial("),
                        "lightning::sign::KeyMaterial" if is_ref=> Some("&::lightning::sign::KeyMaterial( unsafe { *"),
                        "lightning::chain::ClaimId" if !is_ref => Some("::lightning::chain::ClaimId("),
@@ -1244,13 +1250,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "[u8; 12]" if !is_ref => Some(".data"),
                        "[u8; 4]" if !is_ref => Some(".data"),
                        "[u8; 3]" if !is_ref => Some(".data"),
-                       "[u16; 8]" if !is_ref => Some(".data"),
+                       "[u16; 32]" if !is_ref => Some(".data"),
 
                        "[u8]" if is_ref => Some(".to_slice()"),
                        "[usize]" if is_ref => Some(".to_slice()"),
 
                        "str" if is_ref => Some(".into_str()"),
                        "alloc::string::String"|"String" => Some(".into_string()"),
+                       "std::path::PathBuf" => Some(".into_pathbuf()"),
                        "std::io::Error"|"lightning::io::Error" => Some(".to_rust()"),
                        "lightning::io::ErrorKind" => Some(".to_rust_kind()"),
 
@@ -1270,7 +1277,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "core::num::NonZeroU8" => Some(").expect(\"Value must be non-zero\")"),
 
                        "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(".into_rust()"),
-                       "bitcoin::secp256k1::ecdsa::Signature" => Some(".into_rust()"),
+                       "bitcoin::secp256k1::ecdsa::Signature"|"bitcoin::secp256k1::schnorr::Signature" => Some(".into_rust()"),
                        "bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some(".into_rust()"),
                        "bitcoin::secp256k1::SecretKey" if !is_ref => Some(".into_rust()"),
                        "bitcoin::secp256k1::SecretKey" if is_ref => Some("}[..]).unwrap()"),
@@ -1311,10 +1318,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if !is_ref => Some(".data)"),
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if is_ref => Some(" })"),
 
                        // List of traits we map (possibly during processing of other files):
@@ -1355,13 +1364,13 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "[u8; 12]" if !is_ref => Some("crate::c_types::TwelveBytes { data: "),
                        "[u8; 4]" if !is_ref => Some("crate::c_types::FourBytes { data: "),
                        "[u8; 3]" if is_ref => Some(""),
-                       "[u16; 8]" if !is_ref => Some("crate::c_types::EightU16s { data: "),
+                       "[u16; 32]" if !is_ref => Some("crate::c_types::ThirtyTwoU16s { data: "),
 
                        "[u8]" if is_ref => Some("local_"),
                        "[usize]" if is_ref => Some("local_"),
 
                        "str" if is_ref => Some(""),
-                       "alloc::string::String"|"String" => Some(""),
+                       "alloc::string::String"|"String"|"std::path::PathBuf" => Some(""),
 
                        "bitcoin::Address" => Some("alloc::string::ToString::to_string(&"),
 
@@ -1385,7 +1394,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "u128" => Some(""),
 
                        "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some("crate::c_types::PublicKey::from_rust(&"),
-                       "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::Signature::from_rust(&"),
+                       "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::ECDSASignature::from_rust(&"),
+                       "bitcoin::secp256k1::schnorr::Signature" => Some("crate::c_types::SchnorrSignature::from_rust(&"),
                        "bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some("crate::c_types::RecoverableSignature::from_rust(&"),
                        "bitcoin::secp256k1::SecretKey" if is_ref => Some(""),
                        "bitcoin::secp256k1::SecretKey" if !is_ref => Some("crate::c_types::SecretKey::from_rust("),
@@ -1429,10 +1439,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if is_ref => Some("&"),
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if !is_ref => Some("crate::c_types::ThirtyTwoBytes { data: "),
 
                        "lightning::io::Read" => Some("crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec("),
@@ -1456,14 +1468,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "[u8; 12]" if !is_ref => Some(" }"),
                        "[u8; 4]" if !is_ref => Some(" }"),
                        "[u8; 3]" if is_ref => Some(""),
-                       "[u16; 8]" if !is_ref => Some(" }"),
+                       "[u16; 32]" if !is_ref => Some(" }"),
 
                        "[u8]" if is_ref => Some(""),
                        "[usize]" if is_ref => Some(""),
 
                        "str" if is_ref => Some(".into()"),
-                       "alloc::string::String"|"String" if is_ref => Some(".as_str().into()"),
-                       "alloc::string::String"|"String" => Some(".into()"),
+                       "alloc::string::String"|"String"|"std::path::PathBuf" if is_ref => Some(".as_str().into()"),
+                       "alloc::string::String"|"String"|"std::path::PathBuf" => Some(".into()"),
 
                        "bitcoin::Address" => Some(").into()"),
 
@@ -1486,7 +1498,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "u128" => Some(".into()"),
 
                        "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(")"),
-                       "bitcoin::secp256k1::ecdsa::Signature" => Some(")"),
+                       "bitcoin::secp256k1::ecdsa::Signature"|"bitcoin::secp256k1::schnorr::Signature" => Some(")"),
                        "bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some(")"),
                        "bitcoin::secp256k1::SecretKey" if !is_ref => Some(")"),
                        "bitcoin::secp256k1::SecretKey" if is_ref => Some(".as_ref()"),
@@ -1528,10 +1540,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if is_ref => Some(".0"),
                        "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
                        |"lightning::ln::channelmanager::PaymentId"|"lightning::ln::channelmanager::InterceptId"
                        |"lightning::sign::KeyMaterial"|"lightning::chain::ClaimId"
+                       |"lightning::ln::ChannelId"|"lightning::ln::channel_id::ChannelId"
                                if !is_ref => Some(".0 }"),
 
                        "lightning::io::Read" => Some("))"),

diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index 1cb1eccebd0f0519f5f1a156d29fd90bf7e8b802..eb9be439a1acf06b9a7ab8fe6b0676b37ccc195d 100644 (file)
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -8,7 +8,8 @@ use bitcoin::Witness as BitcoinWitness;
 use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey as SecpPublicKey;
 use bitcoin::secp256k1::SecretKey as SecpSecretKey;
-use bitcoin::secp256k1::ecdsa::Signature as SecpSignature;
+use bitcoin::secp256k1::ecdsa::Signature as ECDSASecpSignature;
+use bitcoin::secp256k1::schnorr::Signature as SchnorrSecpSignature;
 use bitcoin::secp256k1::Error as SecpError;
 use bitcoin::secp256k1::ecdsa::RecoveryId;
 use bitcoin::secp256k1::ecdsa::RecoverableSignature as SecpRecoverableSignature;
@@ -17,6 +18,7 @@ use bitcoin::bech32;
 use bitcoin::util::address;
 
 use core::convert::TryInto; // Bindings need at least rustc 1.34
+use alloc::borrow::ToOwned;
 use core::ffi::c_void;
 
 #[cfg(feature = "std")]
@@ -135,23 +137,38 @@ impl SecretKey {
 
 #[repr(C)]
 #[derive(Clone)]
-/// Represents a secp256k1 signature serialized as two 32-byte numbers
-pub struct Signature {
+/// Represents a secp256k1 ECDSA signature serialized as two 32-byte numbers
+pub struct ECDSASignature {
        /// The bytes of the signature in "compact" form
        pub compact_form: [u8; 64],
 }
-impl Signature {
-       pub(crate) fn from_rust(pk: &SecpSignature) -> Self {
+impl ECDSASignature {
+       pub(crate) fn from_rust(pk: &ECDSASecpSignature) -> Self {
                Self {
                        compact_form: pk.serialize_compact(),
                }
        }
-       pub(crate) fn into_rust(&self) -> SecpSignature {
-               SecpSignature::from_compact(&self.compact_form).unwrap()
+       pub(crate) fn into_rust(&self) -> ECDSASecpSignature {
+               ECDSASecpSignature::from_compact(&self.compact_form).unwrap()
+       }
+}
+
+#[repr(C)]
+#[derive(Clone)]
+/// Represents a secp256k1 Schnorr signature serialized as two 32-byte numbers
+pub struct SchnorrSignature {
+       /// The bytes of the signature as two 32-byte numbers
+       pub compact_form: [u8; 64],
+}
+impl SchnorrSignature {
+       pub(crate) fn from_rust(pk: &SchnorrSecpSignature) -> Self {
+               Self {
+                       compact_form: pk.as_ref().clone(),
+               }
+       }
+       pub(crate) fn into_rust(&self) -> SchnorrSecpSignature {
+               SchnorrSecpSignature::from_slice(&self.compact_form).unwrap()
        }
-       // The following are used for Option<Signature> which we support, but don't use anymore
-       #[allow(unused)] pub(crate) fn is_null(&self) -> bool { self.compact_form[..] == [0; 64][..] }
-       #[allow(unused)] pub(crate) fn null() -> Self { Self { compact_form: [0; 64] } }
 }
 
 #[repr(C)]
@@ -673,8 +690,8 @@ pub struct TwentyBytes { /** The twenty bytes */ pub data: [u8; 20], }
 
 #[derive(Clone)]
 #[repr(C)]
-/// 8 u16s
-pub struct EightU16s { /** The eight 16-bit integers */ pub data: [u16; 8], }
+/// 32 u16s
+pub struct ThirtyTwoU16s { /** The thirty-two 16-bit integers */ pub data: [u16; 32], }
 
 pub(crate) struct VecWriter(pub Vec<u8>);
 impl lightning::util::ser::Writer for VecWriter {
@@ -709,14 +726,14 @@ pub struct Str {
        /// Whether the data pointed to by `chars` should be freed or not.
        pub chars_is_owned: bool,
 }
-impl Into<Str> for &'static str {
+impl Into<Str> for &str {
        fn into(self) -> Str {
-               Str { chars: self.as_ptr(), len: self.len(), chars_is_owned: false }
+               self.to_owned().into()
        }
 }
-impl Into<Str> for &mut &'static str {
+impl Into<Str> for &mut &str {
        fn into(self) -> Str {
-               let us: &'static str = *self;
+               let us: &str = *self;
                us.into()
        }
 }
@@ -742,6 +759,10 @@ impl Str {
                };
                String::from_utf8(bytes).unwrap()
        }
+       #[cfg(feature = "std")]
+       pub(crate) fn into_pathbuf(mut self) -> std::path::PathBuf {
+               std::path::PathBuf::from(self.into_string())
+       }
 }
 impl Into<Str> for String {
        fn into(self) -> Str {
@@ -749,6 +770,12 @@ impl Into<Str> for String {
                Str { chars: s.as_ptr(), len: s.len(), chars_is_owned: true }
        }
 }
+#[cfg(feature = "std")]
+impl Into<Str> for std::path::PathBuf {
+       fn into(self) -> Str {
+               self.into_os_string().into_string().expect("We expect paths to be UTF-8 valid").into()
+       }
+}
 impl Clone for Str {
        fn clone(&self) -> Self {
                String::from(self.into_str()).into()