feat: hash and coversion

Author: apskhem

rust/catalyst-types/Cargo.toml

@@ -16,5 +16,12 @@ workspace = true
 name = "catalyst_types"
 
 [dependencies]
+anyhow = "1.0.95"
+blake2b_simd = "1.0.2"
+ed25519-dalek = "2.1.1"
+hex = "0.4.3"
+minicbor = { version = "0.25.1", features = ["std"] }
+num-traits = "0.2.19"
 orx-concurrent-vec = "3.1.0"
+pallas-crypto = { version = "0.30.1", git = "https://github.com/input-output-hk/catalyst-pallas.git", rev = "9b5183c8b90b90fe2cc319d986e933e9518957b3" }
 serde = { version = "1.0.217", features = ["derive"] }

rust/catalyst-types/src/conversion.rs

@@ -0,0 +1,55 @@
+//! Conversion functions
+
+use anyhow::bail;
+
+/// Convert an `<T>` to `<R>` (saturate if out of range).
+/// Note can convert any int to float, or f32 to f64 as well.
+/// can not convert from float to int, or f64 to f32.
+pub fn from_saturating<
+    R: Copy + num_traits::identities::Zero + num_traits::Bounded,
+    T: Copy
+        + TryInto<R>
+        + std::ops::Sub<Output = T>
+        + std::cmp::PartialOrd<T>
+        + num_traits::identities::Zero,
+>(
+    value: T,
+) -> R {
+    match value.try_into() {
+        Ok(value) => value,
+        Err(_) => {
+            // If we couldn't convert, its out of range for the destination type.
+            if value > T::zero() {
+                // If the number is positive, its out of range in the positive direction.
+                R::max_value()
+            } else {
+                // Otherwise its out of range in the negative direction.
+                R::min_value()
+            }
+        },
+    }
+}
+
+/// Try and convert a byte array into an ed25519 verifying key.
+///
+/// # Errors
+///
+/// Fails if the bytes are not a valid ED25519 Public Key
+pub fn vkey_from_bytes(bytes: &[u8]) -> anyhow::Result<ed25519_dalek::VerifyingKey> {
+    if bytes.len() != ed25519_dalek::PUBLIC_KEY_LENGTH {
+        bail!(
+            "Failed to convert bytes to ED25519 public key. Expected {} bytes, got {}",
+            ed25519_dalek::PUBLIC_KEY_LENGTH,
+            bytes.len()
+        );
+    }
+
+    let mut ed25519 = [0u8; ed25519_dalek::PUBLIC_KEY_LENGTH];
+    ed25519.copy_from_slice(bytes); // Can't panic because we already validated its size.
+
+    let pubkey = match ed25519_dalek::VerifyingKey::from_bytes(&ed25519) {
+        Ok(key) => key,
+        Err(err) => bail!("Failed to convert Ed25519 public key in SimplePublicKeyType {err}"),
+    };
+    Ok(pubkey)
+}

rust/catalyst-types/src/hashes.rs

@@ -0,0 +1,144 @@
+//! Cardano hashing functions
+
+use std::{fmt, str::FromStr};
+
+use anyhow::bail;
+use blake2b_simd::Params;
+use pallas_crypto::hash::Hash;
+
+/// Number of bytes in a blake2b 224 hash.
+pub const BLAKE_2B224_SIZE: usize = 224 / 8;
+
+/// `Blake2B` 224bit Hash.
+pub type Blake2b224Hash = Blake2bHash<BLAKE_2B224_SIZE>;
+
+/// Number of bytes in a blake2b 256 hash.
+pub const BLAKE_2B256_SIZE: usize = 256 / 8;
+
+/// `Blake2B` 256bit Hash
+pub type Blake2b256Hash = Blake2bHash<BLAKE_2B256_SIZE>;
+
+/// Number of bytes in a blake2b 128 hash.
+pub const BLAKE_2B128_SIZE: usize = 128 / 8;
+
+/// `Blake2B` 128bit Hash
+pub type Blake2b128Hash = Blake2bHash<BLAKE_2B128_SIZE>;
+
+/// data that is a blake2b [`struct@Hash`] of `BYTES` long.
+///
+/// Possible values with Cardano are 32 bytes long (block hash or transaction
+/// hash). Or 28 bytes long (as used in addresses)
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Blake2bHash<const BYTES: usize>(Hash<BYTES>);
+
+impl<const BYTES: usize> Blake2bHash<BYTES> {
+    /// Create a new `Blake2bHash` from a slice of bytes by hashing them.
+    #[must_use]
+    pub fn new(input_bytes: &[u8]) -> Self {
+        let mut bytes: [u8; BYTES] = [0u8; BYTES];
+
+        // Generate a unique hash of the data.
+        let mut hasher = Params::new().hash_length(BYTES).to_state();
+
+        hasher.update(input_bytes);
+        let hash = hasher.finalize();
+
+        // Create a new array containing the first BYTES elements from the original array
+        bytes.copy_from_slice(hash.as_bytes());
+
+        bytes.into()
+    }
+}
+
+impl<const BYTES: usize> From<[u8; BYTES]> for Blake2bHash<BYTES> {
+    #[inline]
+    fn from(bytes: [u8; BYTES]) -> Self {
+        let hash: Hash<BYTES> = bytes.into();
+        hash.into()
+    }
+}
+
+impl<const BYTES: usize> From<Hash<BYTES>> for Blake2bHash<BYTES> {
+    #[inline]
+    fn from(bytes: Hash<BYTES>) -> Self {
+        Self(bytes)
+    }
+}
+
+impl<const BYTES: usize> From<Blake2bHash<BYTES>> for Vec<u8> {
+    fn from(val: Blake2bHash<BYTES>) -> Self {
+        val.0.to_vec()
+    }
+}
+
+/// Convert hash in a form of byte array into the `Blake2bHash` type.
+impl<const BYTES: usize> TryFrom<&[u8]> for Blake2bHash<BYTES> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        if value.len() < BYTES {
+            bail!("Invalid input length");
+        }
+
+        let mut hash = [0; BYTES];
+        hash.copy_from_slice(value);
+        let hash: Hash<BYTES> = hash.into();
+        Ok(hash.into())
+    }
+}
+
+impl<const BYTES: usize> TryFrom<&Vec<u8>> for Blake2bHash<BYTES> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
+        value.as_slice().try_into()
+    }
+}
+
+impl<const BYTES: usize> TryFrom<Vec<u8>> for Blake2bHash<BYTES> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+        value.as_slice().try_into()
+    }
+}
+
+impl<const BYTES: usize> fmt::Debug for Blake2bHash<BYTES> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("{:?}", self.0))
+    }
+}
+
+impl<const BYTES: usize> fmt::Display for Blake2bHash<BYTES> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("{}", self.0))
+    }
+}
+
+impl<const BYTES: usize> FromStr for Blake2bHash<BYTES> {
+    type Err = hex::FromHexError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let hash: Hash<BYTES> = s.parse()?;
+        Ok(hash.into())
+    }
+}
+
+impl<C, const BYTES: usize> minicbor::Encode<C> for Blake2bHash<BYTES> {
+    fn encode<W: minicbor::encode::Write>(
+        &self, e: &mut minicbor::Encoder<W>, _ctx: &mut C,
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        e.bytes(self.0.as_ref())?.ok()
+    }
+}
+
+impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Blake2bHash<BYTES> {
+    fn decode(
+        d: &mut minicbor::Decoder<'a>, _ctx: &mut C,
+    ) -> Result<Self, minicbor::decode::Error> {
+        let bytes = d.bytes()?;
+        bytes.try_into().map_err(|_| {
+            minicbor::decode::Error::message("Invalid hash size for Blake2bHash cbor decode")
+        })
+    }
+}

rust/catalyst-types/src/lib.rs

@@ -1,3 +1,5 @@
 //! Catalyst Generic Types
 
+pub mod conversion;
+pub mod hashes;
 pub mod problem_report;