Update `lightning-c-bindings` to new `bitcoin`/`secp256k1`

[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 f31d55bd1b2c7d9ec67f30552f0036d27e5b28a6..71aa6793cc25c9c3f2de853dedb9de0ff90e5f2b 100644 (file)
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -5,12 +5,12 @@ 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 core::convert::TryInto; // Bindings need at least rustc 1.34
@@ -146,14 +146,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,12 +167,88 @@ 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::NotEnoughMemory => SecpError::NotEnoughMemory,
+                       Secp256k1Error::InvalidPublicKeySum => SecpError::InvalidPublicKeySum,
+                       Secp256k1Error::InvalidParityValue => SecpError::InvalidParityValue(invalid_parity),
+               }
+       }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+/// Represents an error returned from the bech32 library during validation of some bech32 data
+pub enum Bech32Error {
+       /// String does not contain the separator character
+       MissingSeparator,
+       /// The checksum does not match the rest of the data
+       InvalidChecksum,
+       /// The data or human-readable part is too long or too short
+       InvalidLength,
+       /// Some part of the string contains an invalid character
+       InvalidChar(u32),
+       /// Some part of the data has an invalid value
+       InvalidData(u8),
+       /// The bit conversion failed due to a padding issue
+       InvalidPadding,
+       /// The whole string must be of one case
+       MixedCase,
+}
+impl Bech32Error {
+       pub(crate) fn from_rust(err: bech32::Error) -> Self {
+               match err {
+                       bech32::Error::MissingSeparator => Self::MissingSeparator,
+                       bech32::Error::InvalidChecksum => Self::InvalidChecksum,
+                       bech32::Error::InvalidLength => Self::InvalidLength,
+                       bech32::Error::InvalidChar(c) => Self::InvalidChar(c as u32),
+                       bech32::Error::InvalidData(d) => Self::InvalidData(d),
+                       bech32::Error::InvalidPadding => Self::InvalidPadding,
+                       bech32::Error::MixedCase => Self::MixedCase,
+               }
+       }
+       pub(crate) fn into_rust(self) -> bech32::Error {
+               match self {
+                       Self::MissingSeparator => bech32::Error::MissingSeparator,
+                       Self::InvalidChecksum => bech32::Error::InvalidChecksum,
+                       Self::InvalidLength => bech32::Error::InvalidLength,
+                       Self::InvalidChar(c) => bech32::Error::InvalidChar(core::char::from_u32(c).expect("Invalid UTF-8 character in Bech32Error::InvalidChar")),
+                       Self::InvalidData(d) => bech32::Error::InvalidData(d),
+                       Self::InvalidPadding => bech32::Error::InvalidPadding,
+                       Self::MixedCase => bech32::Error::MixedCase,
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new Bech32Error which has the same data as `orig`
+pub extern "C" fn Bech32Error_clone(orig: &Bech32Error) -> Bech32Error { orig.clone() }
+#[no_mangle]
+/// Releases any memory held by the given `Bech32Error` (which is currently none)
+pub extern "C" fn Bech32Error_free(o: Bech32Error) { }
+
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq)]
+/// Sub-errors which don't have specific information in them use this type.
+pub struct Error {
+       /// Zero-Sized_types aren't consistent across Rust/C/C++, so we add some size here
+       pub _dummy: u8,
 }
 
 #[repr(C)]
@@ -498,7 +578,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()
        }
 }