X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Fc_types%2Fmod.rs;fp=lightning-c-bindings%2Fsrc%2Fc_types%2Fmod.rs;h=eb9be439a1acf06b9a7ab8fe6b0676b37ccc195d;hp=1cb1eccebd0f0519f5f1a156d29fd90bf7e8b802;hb=8f7b5720032a79764cd8eff457ff3e21ca72a31e;hpb=737b617b2db60132ef7c89713124460c60a3fcca

diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index 1cb1ecc..eb9be43 100644
--- 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()