Change internal implementation of Piece to be boxed PieceArray to remove the need of mem::transmute in some cases

Author: nazar-pc

crates/subspace-core-primitives/src/pieces.rs

@@ -3,8 +3,10 @@ mod serde;
 
 #[cfg(feature = "serde")]
 use ::serde::{Deserialize, Serialize};
+use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
+use core::array::TryFromSliceError;
 use core::mem;
 use core::ops::{Deref, DerefMut};
 use derive_more::{AsMut, AsRef, Deref, DerefMut};
@@ -68,74 +70,55 @@ impl AsMut<[u8]> for RecordWitness {
 /// Internally piece contains a record and corresponding witness that together with records root of
 /// the segment this piece belongs to can be used to verify that a piece belongs to the actual
 /// archival history of the blockchain.
-#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Encode, Decode, TypeInfo)]
+#[derive(Debug, Default, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Encode, Decode, TypeInfo)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Piece(#[cfg_attr(feature = "serde", serde(with = "hex::serde"))] Vec<u8>);
-
-impl Default for Piece {
-    fn default() -> Self {
-        Self(vec![0u8; PIECE_SIZE])
-    }
-}
+pub struct Piece(Box<PieceArray>);
 
 impl From<Piece> for Vec<u8> {
     fn from(piece: Piece) -> Self {
-        piece.0
+        piece.0.to_vec()
     }
 }
-
 impl TryFrom<&[u8]> for Piece {
-    type Error = &'static str;
+    type Error = TryFromSliceError;
+
     fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
-        if slice.len() != PIECE_SIZE {
-            Err("Wrong piece size, expected: 32768")
-        } else {
-            Ok(Self(slice.to_vec()))
-        }
+        <[u8; PIECE_SIZE]>::try_from(slice).map(|bytes| Piece(Box::new(PieceArray(bytes))))
     }
 }
 
 impl TryFrom<Vec<u8>> for Piece {
-    type Error = &'static str;
+    type Error = TryFromSliceError;
 
     fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
-        if vec.len() != PIECE_SIZE {
-            Err("Wrong piece size, expected: 32768")
-        } else {
-            Ok(Self(vec))
-        }
+        // TODO: Maybe possible to transmute boxed slice into boxed array
+        Self::try_from(vec.as_slice())
     }
 }
 
 impl Deref for Piece {
     type Target = PieceArray;
 
     fn deref(&self) -> &Self::Target {
-        let array =
-            <&[u8; PIECE_SIZE]>::try_from(self.0.as_slice()).expect("Piece has correct size; qed");
-        // SAFETY: Same memory layout due to `#[repr(transparent)]`
-        unsafe { mem::transmute(array) }
+        &self.0
     }
 }
 
 impl DerefMut for Piece {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        let array = <&mut [u8; PIECE_SIZE]>::try_from(self.0.as_mut_slice())
-            .expect("Piece has correct size; qed");
-        // SAFETY: Same memory layout due to `#[repr(transparent)]`
-        unsafe { mem::transmute(array) }
+        &mut self.0
     }
 }
 
 impl AsRef<[u8]> for Piece {
     fn as_ref(&self) -> &[u8] {
-        &self.0
+        self.0.as_slice()
     }
 }
 
 impl AsMut<[u8]> for Piece {
     fn as_mut(&mut self) -> &mut [u8] {
-        &mut self.0
+        self.0.as_mut_slice()
     }
 }
 
@@ -187,13 +170,13 @@ impl AsMut<[u8]> for PieceArray {
 
 impl From<&PieceArray> for Piece {
     fn from(value: &PieceArray) -> Self {
-        Piece(value.0.to_vec())
+        Piece(Box::new(*value))
     }
 }
 
 impl From<PieceArray> for Piece {
     fn from(value: PieceArray) -> Self {
-        Piece(value.0.to_vec())
+        Piece(Box::new(value))
     }
 }
 

crates/subspace-core-primitives/src/pieces/serde.rs

@@ -1,7 +1,104 @@
-use crate::{FlatPieces, PIECE_SIZE};
+use crate::{FlatPieces, PieceArray, PIECE_SIZE};
 use hex::{decode_to_slice, FromHex, FromHexError};
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 
+impl FromHex for PieceArray {
+    type Error = FromHexError;
+
+    fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
+        let hex = hex.as_ref();
+        if hex.len() % 2 != 0 {
+            return Err(FromHexError::OddLength);
+        }
+        if hex.len() != 2 * PIECE_SIZE {
+            return Err(FromHexError::InvalidStringLength);
+        }
+
+        let mut out = Self::default();
+
+        decode_to_slice(hex, out.as_mut_slice())?;
+
+        Ok(out)
+    }
+}
+
+impl Serialize for PieceArray {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        Serializer::serialize_newtype_struct(serializer, "PieceArray", {
+            struct SerializeWith<'a> {
+                values: &'a [u8],
+            }
+            impl<'a> Serialize for SerializeWith<'a> {
+                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: Serializer,
+                {
+                    hex::serde::serialize(self.values, serializer)
+                }
+            }
+            &SerializeWith {
+                values: self.as_ref(),
+            }
+        })
+    }
+}
+
+impl<'de> Deserialize<'de> for PieceArray {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> de::Visitor<'de> for Visitor {
+            type Value = PieceArray;
+
+            fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                formatter.write_str("tuple struct PieceArray")
+            }
+
+            #[inline]
+            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                hex::serde::deserialize(deserializer)
+            }
+
+            #[inline]
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                struct DeserializeWith {
+                    value: PieceArray,
+                }
+                impl<'de> Deserialize<'de> for DeserializeWith {
+                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                    where
+                        D: Deserializer<'de>,
+                    {
+                        Ok(DeserializeWith {
+                            value: hex::serde::deserialize(deserializer)?,
+                        })
+                    }
+                }
+
+                de::SeqAccess::next_element::<DeserializeWith>(&mut seq)?
+                    .map(|wrap| wrap.value)
+                    .ok_or(de::Error::invalid_length(
+                        0usize,
+                        &"tuple struct PieceArray with 1 element",
+                    ))
+            }
+        }
+        Deserializer::deserialize_newtype_struct(deserializer, "PieceArray", Visitor)
+    }
+}
+
 impl FromHex for FlatPieces {
     type Error = FromHexError;