Add C type for bitcoin::util::address::WitnessVersion

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

diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index 1e88f0521e53c8ce56372278b3dcb17d3e4db3e5..471b067ac94fab9d19e1e6f034fdf49d1eea8cc2 100644 (file)
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -5,13 +5,14 @@ pub mod derived;
 
 use bitcoin::Transaction as BitcoinTransaction;
 use bitcoin::hashes::Hash;
-use bitcoin::secp256k1::key::PublicKey as SecpPublicKey;
-use bitcoin::secp256k1::key::SecretKey as SecpSecretKey;
-use bitcoin::secp256k1::Signature as SecpSignature;
+use bitcoin::secp256k1::PublicKey as SecpPublicKey;
+use bitcoin::secp256k1::SecretKey as SecpSecretKey;
+use bitcoin::secp256k1::ecdsa::Signature as SecpSignature;
 use bitcoin::secp256k1::Error as SecpError;
-use bitcoin::secp256k1::recovery::RecoveryId;
-use bitcoin::secp256k1::recovery::RecoverableSignature as SecpRecoverableSignature;
+use bitcoin::secp256k1::ecdsa::RecoveryId;
+use bitcoin::secp256k1::ecdsa::RecoverableSignature as SecpRecoverableSignature;
 use bitcoin::bech32;
+use bitcoin::util::address;
 
 use core::convert::TryInto; // Bindings need at least rustc 1.34
 use core::ffi::c_void;
@@ -46,6 +47,18 @@ impl Into<bech32::u5> for u5 {
        fn into(self) -> bech32::u5 { bech32::u5::try_from_u8(self.0).expect("u5 objects must be in the range 0..32") }
 }
 
+/// Integer in the range `0..=16`
+#[derive(PartialEq, Eq, Copy, Clone)]
+#[repr(C)]
+pub struct WitnessVersion(u8);
+
+impl From<address::WitnessVersion> for WitnessVersion {
+       fn from(o: address::WitnessVersion) -> Self { Self(o.into_num()) }
+}
+impl Into<address::WitnessVersion> for WitnessVersion {
+       fn into(self) -> address::WitnessVersion { address::WitnessVersion::from_num(self.0).expect("WitnessVersion objects must be in the range 0..=16") }
+}
+
 #[derive(Clone)]
 #[repr(C)]
 /// Represents a valid secp256k1 public key serialized in "compressed form" as a 33 byte array.
@@ -146,14 +159,18 @@ pub enum Secp256k1Error {
        InvalidSignature,
        /// Bad secret key
        InvalidSecretKey,
+       /// Bad shared secret.
+       InvalidSharedSecret,
        /// Bad recovery id
        InvalidRecoveryId,
        /// Invalid tweak for add_assign or mul_assign
        InvalidTweak,
-       /// tweak_add_check failed on an xonly public key
-       TweakCheckFailed,
        /// Didn't pass enough memory to context creation with preallocated memory
        NotEnoughMemory,
+       /// Bad set of public keys.
+       InvalidPublicKeySum,
+       /// The only valid parity values are 0 or 1.
+       InvalidParityValue,
 }
 impl Secp256k1Error {
        pub(crate) fn from_rust(err: SecpError) -> Self {
@@ -163,23 +180,28 @@ impl Secp256k1Error {
                        SecpError::InvalidPublicKey => Secp256k1Error::InvalidPublicKey,
                        SecpError::InvalidSignature => Secp256k1Error::InvalidSignature,
                        SecpError::InvalidSecretKey => Secp256k1Error::InvalidSecretKey,
+                       SecpError::InvalidSharedSecret => Secp256k1Error::InvalidSharedSecret,
                        SecpError::InvalidRecoveryId => Secp256k1Error::InvalidRecoveryId,
                        SecpError::InvalidTweak => Secp256k1Error::InvalidTweak,
-                       SecpError::TweakCheckFailed => Secp256k1Error::TweakCheckFailed,
                        SecpError::NotEnoughMemory => Secp256k1Error::NotEnoughMemory,
+                       SecpError::InvalidPublicKeySum => Secp256k1Error::InvalidPublicKeySum,
+                       SecpError::InvalidParityValue(_) => Secp256k1Error::InvalidParityValue,
                }
        }
        pub(crate) fn into_rust(self) -> SecpError {
+               let invalid_parity = secp256k1::Parity::from_i32(42).unwrap_err();
                match self {
                        Secp256k1Error::IncorrectSignature => SecpError::IncorrectSignature,
                        Secp256k1Error::InvalidMessage => SecpError::InvalidMessage,
                        Secp256k1Error::InvalidPublicKey => SecpError::InvalidPublicKey,
                        Secp256k1Error::InvalidSignature => SecpError::InvalidSignature,
                        Secp256k1Error::InvalidSecretKey => SecpError::InvalidSecretKey,
+                       Secp256k1Error::InvalidSharedSecret => SecpError::InvalidSharedSecret,
                        Secp256k1Error::InvalidRecoveryId => SecpError::InvalidRecoveryId,
                        Secp256k1Error::InvalidTweak => SecpError::InvalidTweak,
-                       Secp256k1Error::TweakCheckFailed => SecpError::TweakCheckFailed,
                        Secp256k1Error::NotEnoughMemory => SecpError::NotEnoughMemory,
+                       Secp256k1Error::InvalidPublicKeySum => SecpError::InvalidPublicKeySum,
+                       Secp256k1Error::InvalidParityValue => SecpError::InvalidParityValue(invalid_parity),
                }
        }
 }
@@ -569,7 +591,7 @@ impl Into<Str> for String {
 }
 impl Clone for Str {
        fn clone(&self) -> Self {
-               self.into_str().clone().into()
+               String::from(self.into_str()).into()
        }
 }