X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Fc_types%2Fmod.rs;h=71aa6793cc25c9c3f2de853dedb9de0ff90e5f2b;hb=8af4116fe7c878945f08c85e5040cb24a6d26c55;hp=9e928a6065922e87409de08506ddf04e26e945a4;hpb=a032db3b20a0b3f70592eba1598af10b96f37b88;p=ldk-c-bindings diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs index 9e928a6..71aa679 100644 --- 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 @@ -20,6 +20,8 @@ use core::ffi::c_void; pub(crate) use std::io::{self, Cursor, Read}; #[cfg(feature = "no-std")] pub(crate) use core2::io::{self, Cursor, Read}; +#[cfg(feature = "no-std")] +use alloc::{boxed::Box, vec::Vec, string::String}; #[repr(C)] /// A dummy struct of which an instance must never exist. @@ -65,6 +67,7 @@ impl PublicKey { } #[repr(C)] +#[derive(Clone)] /// Represents a valid secp256k1 secret key serialized as a 32 byte array. pub struct SecretKey { /// The bytes of the secret key @@ -143,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 { @@ -160,14 +167,90 @@ 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)] #[allow(missing_docs)] // If there's no docs upstream, that's good enough for us #[derive(Clone, Copy, PartialEq)] @@ -192,6 +275,7 @@ pub enum IOError { Other, UnexpectedEof, } +#[cfg(feature = "std")] impl IOError { pub(crate) fn from_rust(err: std::io::Error) -> Self { match err.kind() { @@ -494,7 +578,7 @@ impl Into for String { } impl Clone for Str { fn clone(&self) -> Self { - self.into_str().clone().into() + String::from(self.into_str()).into() } } @@ -576,6 +660,9 @@ impl TakePointer<*mut T> for *mut T { pub(crate) mod ObjOps { + #[cfg(feature = "no-std")] + use alloc::boxed::Box; + #[inline] #[must_use = "returns new dangling pointer"] pub(crate) fn heap_alloc(obj: T) -> *mut T {