Remove -scylla dependency

Author: stanislav-tkach

rust/cardano-blockchain-types/src/hashes.rs

@@ -74,29 +74,6 @@ macro_rules! define_hashes {
                     Ok(Self(hash))
                 }
             }
-
-            // TODO: Uncomment when the changes to Blake2bHash are merged.
-            // impl SerializeValue for $name {
-            //     fn serialize<'b>(
-            //         &self, typ: &ColumnType, writer: CellWriter<'b>,
-            //     ) -> Result<WrittenCellProof<'b>, SerializationError> {
-            //         self.0.serialize(typ, writer)
-            //     }
-            // }
-            //
-            // impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for $name
-            // {
-            //     fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
-            //         <$inner>::type_check(typ)
-            //     }
-            //
-            //     fn deserialize(
-            //         typ: &'metadata ColumnType<'metadata>, v: Option<FrameSlice<'frame>>,
-            //     ) -> Result<Self, DeserializationError> {
-            //         let hash = <$inner>::deserialize(typ, v)?;
-            //         Ok(Self(hash))
-            //     }
-            // }
         )+
     };
 }

rust/catalyst-types/Cargo.toml

@@ -33,7 +33,6 @@ chrono = "0.4.39"
 fmmap = { version = "0.3.3", features = ["sync", "tokio-async"] }
 once_cell = "1.20.2"
 tracing = "0.1.41"
-scylla = "0.15.1"
 
 [dev-dependencies]
 ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }

rust/catalyst-types/src/hashes.rs

@@ -5,10 +5,6 @@ use std::{fmt, str::FromStr};
 use blake2b_simd::Params;
 use displaydoc::Display;
 use pallas_crypto::hash::Hash;
-use scylla::_macro_internal::{
-    CellWriter, ColumnType, DeserializationError, DeserializeValue, FrameSlice, SerializationError,
-    SerializeValue, TypeCheckError, WrittenCellProof,
-};
 use thiserror::Error;
 
 /// Number of bytes in a blake2b 224 hash.
@@ -169,29 +165,6 @@ impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Blake2bHash<BYTES> {
     }
 }
 
-impl<const BYTES: usize> SerializeValue for Blake2bHash<BYTES> {
-    fn serialize<'b>(
-        &self, typ: &ColumnType, writer: CellWriter<'b>,
-    ) -> Result<WrittenCellProof<'b>, SerializationError> {
-        self.0.as_ref().serialize(typ, writer)
-    }
-}
-
-impl<'frame, 'metadata, const BYTES: usize> DeserializeValue<'frame, 'metadata>
-    for Blake2bHash<BYTES>
-{
-    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
-        <Vec<u8>>::type_check(typ)
-    }
-
-    fn deserialize(
-        typ: &'metadata ColumnType<'metadata>, v: Option<FrameSlice<'frame>>,
-    ) -> Result<Self, DeserializationError> {
-        let bytes = <Vec<u8>>::deserialize(typ, v)?;
-        Self::try_from(bytes).map_err(DeserializationError::new)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

rust/catalyst-types/src/uuid/uuid_v4.rs

@@ -2,13 +2,6 @@
 use std::fmt::{Display, Formatter};
 
 use minicbor::{Decode, Decoder, Encode};
-use scylla::{
-    _macro_internal::{
-        CellWriter, ColumnType, DeserializationError, FrameSlice, SerializationError,
-        SerializeValue, TypeCheckError, WrittenCellProof,
-    },
-    deserialize::DeserializeValue,
-};
 use serde::Deserialize;
 use uuid::Uuid;
 
@@ -114,31 +107,6 @@ impl<'de> serde::Deserialize<'de> for UuidV4 {
     }
 }
 
-impl SerializeValue for UuidV4 {
-    fn serialize<'b>(
-        &self, typ: &ColumnType, writer: CellWriter<'b>,
-    ) -> Result<WrittenCellProof<'b>, SerializationError> {
-        self.0.serialize(typ, writer)
-    }
-}
-
-impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for UuidV4 {
-    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
-        Uuid::type_check(typ)
-    }
-
-    fn deserialize(
-        typ: &'metadata ColumnType<'metadata>, v: Option<FrameSlice<'frame>>,
-    ) -> Result<Self, DeserializationError> {
-        let uuid = <Uuid as DeserializeValue>::deserialize(typ, v)?;
-        if is_valid(&uuid) {
-            Ok(Self(uuid))
-        } else {
-            Err(DeserializationError::new(UuidError::InvalidUuidV4(uuid)))
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

rust/catalyst-types/src/uuid/uuid_v7.rs

@@ -2,10 +2,6 @@
 use std::fmt::{Display, Formatter};
 
 use minicbor::{Decode, Decoder, Encode};
-use scylla::_macro_internal::{
-    CellWriter, ColumnType, DeserializationError, DeserializeValue, FrameSlice, SerializationError,
-    SerializeValue, TypeCheckError, WrittenCellProof,
-};
 use serde::Deserialize;
 use uuid::Uuid;
 
@@ -111,31 +107,6 @@ impl<'de> serde::Deserialize<'de> for UuidV7 {
     }
 }
 
-impl SerializeValue for UuidV7 {
-    fn serialize<'b>(
-        &self, typ: &ColumnType, writer: CellWriter<'b>,
-    ) -> Result<WrittenCellProof<'b>, SerializationError> {
-        self.0.serialize(typ, writer)
-    }
-}
-
-impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for UuidV7 {
-    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
-        Uuid::type_check(typ)
-    }
-
-    fn deserialize(
-        typ: &'metadata ColumnType<'metadata>, v: Option<FrameSlice<'frame>>,
-    ) -> Result<Self, DeserializationError> {
-        let uuid = <Uuid as DeserializeValue>::deserialize(typ, v)?;
-        if is_valid(&uuid) {
-            Ok(Self(uuid))
-        } else {
-            Err(DeserializationError::new(UuidError::InvalidUuidV4(uuid)))
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use uuid::Uuid;