remove unchecked implementation

Author: Shourya742

sv2/binary-sv2/src/datatypes/copy_data_types.rs

@@ -12,8 +12,8 @@
 //
 // ### `Sv2DataType`
 // The `Sv2DataType` trait is implemented for these data types, providing methods for encoding and
-// decoding operations such as `from_bytes_unchecked`, `from_vec_`, `from_reader_` (if `std` is
-// available), and `to_slice_unchecked`. The methods use little-endian byte order for consistency
+// decoding operations such as `from_bytes_`, `from_reader_` (if `std` is available), and
+// `to_slice`. The methods use little-endian byte order for consistency
 // across platforms.
 //
 // ## Special Types
@@ -27,7 +27,11 @@
 // The `impl_sv2_for_unsigned` macro streamlines the implementation of the `Sv2DataType` trait for
 // unsigned integer types, ensuring little-endian byte ordering for serialization and handling both
 // in-memory buffers and `std::io::Read`/`Write` interfaces when `std` is available.
-use crate::{codec::Fixed, datatypes::Sv2DataType, Error};
+use crate::{
+    codec::{Fixed, SizeHint},
+    datatypes::Sv2DataType,
+    Error,
+};
 use core::convert::{TryFrom, TryInto};
 
 #[cfg(not(feature = "no_std"))]
@@ -40,8 +44,9 @@ impl Fixed for bool {
 }
 
 impl<'a> Sv2DataType<'a> for bool {
-    fn from_bytes_unchecked(data: &'a mut [u8]) -> Self {
-        match data
+    fn from_bytes_(data: &'a mut [u8]) -> Result<Self, Error> {
+        bool::size_hint(data, 0)?;
+        let value = match data
             .first()
             .map(|x: &u8| x << 7)
             .map(|x: u8| x >> 7)
@@ -50,7 +55,8 @@ impl<'a> Sv2DataType<'a> for bool {
             0 => false,
             1 => true,
             _ => panic!(),
-        }
+        };
+        Ok(value)
     }
 
     #[cfg(not(feature = "no_std"))]
@@ -60,11 +66,15 @@ impl<'a> Sv2DataType<'a> for bool {
         Self::from_bytes_(&mut dst)
     }
 
-    fn to_slice_unchecked(&'a self, dst: &mut [u8]) {
+    fn to_slice(&'a self, dst: &mut [u8]) -> Result<usize, Error> {
+        if dst.len() < Self::SIZE {
+            return Err(Error::WriteError(Self::SIZE, dst.len()));
+        }
         match self {
             true => dst[0] = 1,
             false => dst[0] = 0,
         };
+        Ok(Self::SIZE)
     }
 
     #[cfg(not(feature = "no_std"))]
@@ -102,25 +112,29 @@ impl Fixed for u64 {
 macro_rules! impl_sv2_for_unsigned {
     ($a:ty) => {
         impl<'a> Sv2DataType<'a> for $a {
-            fn from_bytes_unchecked(data: &'a mut [u8]) -> Self {
-                // unchecked function is fine to panic
+            fn from_bytes_(data: &'a mut [u8]) -> Result<Self, Error> {
+                Self::size_hint(data, 0)?;
                 let a: &[u8; Self::SIZE] = data[0..Self::SIZE].try_into().expect(
                     "Try to decode a copy data type from a buffer that do not have enough bytes",
                 );
-                Self::from_le_bytes(*a)
+                Ok(Self::from_le_bytes(*a))
             }
 
             #[cfg(not(feature = "no_std"))]
             fn from_reader_(reader: &mut impl Read) -> Result<Self, Error> {
                 let mut dst = [0_u8; Self::SIZE];
                 reader.read_exact(&mut dst)?;
-                Ok(Self::from_bytes_unchecked(&mut dst))
+                Ok(Self::from_le_bytes(dst))
             }
 
-            fn to_slice_unchecked(&'a self, dst: &mut [u8]) {
+            fn to_slice(&'a self, dst: &mut [u8]) -> Result<usize, Error> {
+                if dst.len() < Self::SIZE {
+                    return Err(Error::WriteError(Self::SIZE, dst.len()));
+                }
                 let dst = &mut dst[0..Self::SIZE];
                 let src = self.to_le_bytes();
                 dst.copy_from_slice(&src);
+                Ok(Self::SIZE)
             }
 
             #[cfg(not(feature = "no_std"))]

sv2/binary-sv2/src/datatypes/mod.rs

@@ -10,9 +10,7 @@
 // - **Deserialize**: Convert byte slices or reader sources into Rust types.
 // - **Serialize**: Encode Rust types into byte slices or write them to I/O streams.
 //
-// Supports both **checked** and **unchecked** variants for serialization and deserialization.
-// Checked functions validate data lengths, while unchecked versions assume size correctness for
-// optimized performance.
+// Checked functions validate data lengths before decoding or encoding.
 //
 // ### Modules
 // - **`copy_data_types`**: Defines fixed-size types directly copied into or from byte slices, such
@@ -55,41 +53,19 @@ use std::io::{Error as E, Read, Write};
 /// - Deserialization: Converting byte slices or streams back into the in-memory representation of
 ///   the data.
 ///
-/// This trait includes functions for both checked and unchecked conversions, providing flexibility
-/// in situations where error handling can be safely ignored.
 pub trait Sv2DataType<'a>: Sized + SizeHint + GetSize + TryInto<FieldMarker> {
     /// Creates an instance of the type from a mutable byte slice, checking for size constraints.
     ///
     /// This function verifies that the provided byte slice has the correct size according to the
     /// type's size hint.
-    fn from_bytes_(data: &'a mut [u8]) -> Result<Self, Error> {
-        let size = Self::size_hint(data, 0)?;
-        if size > data.len() {
-            return Err(Error::ReadError(data.len(), size));
-        }
-        let (head, _) = data.split_at_mut(size);
-        Ok(Self::from_bytes_unchecked(head))
-    }
-
-    /// Constructs an instance from a mutable byte slice without verifying size constraints.
-    fn from_bytes_unchecked(data: &'a mut [u8]) -> Self;
+    fn from_bytes_(data: &'a mut [u8]) -> Result<Self, Error>;
 
     // Constructs an instance from a reader source, checking for size constraints.
     #[cfg(not(feature = "no_std"))]
     fn from_reader_(reader: &mut impl Read) -> Result<Self, Error>;
 
     /// Serializes the instance to a mutable slice, checking the destination size.
-    fn to_slice(&'a self, dst: &mut [u8]) -> Result<usize, Error> {
-        if dst.len() >= self.get_size() {
-            self.to_slice_unchecked(dst);
-            Ok(self.get_size())
-        } else {
-            Err(Error::WriteError(self.get_size(), dst.len()))
-        }
-    }
-
-    /// Serializes the instance to a mutable slice without checking the destination size.
-    fn to_slice_unchecked(&'a self, dst: &mut [u8]);
+    fn to_slice(&'a self, dst: &mut [u8]) -> Result<usize, Error>;
 
     // Serializes the instance to a writer destination, checking for I/O errors.
     #[cfg(not(feature = "no_std"))]

sv2/binary-sv2/src/datatypes/non_copy_data_types/inner.rs

@@ -333,11 +333,16 @@ impl<'a, const ISFIXED: bool, const SIZE: usize, const HEADERSIZE: usize, const
 where
     Self: TryInto<FieldMarker>,
 {
-    fn from_bytes_unchecked(data: &'a mut [u8]) -> Self {
+    fn from_bytes_(data: &'a mut [u8]) -> Result<Self, Error> {
+        let size = Self::size_hint(data, 0)?;
+        if size > data.len() {
+            return Err(Error::ReadError(data.len(), size));
+        }
+        let (head, _) = data.split_at_mut(size);
         if ISFIXED {
-            Self::Ref(data)
+            Ok(Self::Ref(head))
         } else {
-            Self::Ref(&mut data[HEADERSIZE..])
+            Ok(Self::Ref(&mut head[HEADERSIZE..]))
         }
     }
 
@@ -351,8 +356,11 @@ where
         Ok(Self::Owned(dst))
     }
 
-    fn to_slice_unchecked(&'a self, dst: &mut [u8]) {
+    fn to_slice(&'a self, dst: &mut [u8]) -> Result<usize, Error> {
         let size = self.get_size();
+        if dst.len() < size {
+            return Err(Error::WriteError(size, dst.len()));
+        }
         let header = self.get_header();
         dst[0..HEADERSIZE].copy_from_slice(&header[..HEADERSIZE]);
         match self {
@@ -365,6 +373,7 @@ where
                 dst[HEADERSIZE..].copy_from_slice(data);
             }
         }
+        Ok(size)
     }
 
     #[cfg(not(feature = "no_std"))]

sv2/binary-sv2/src/datatypes/non_copy_data_types/seq_inner.rs

@@ -306,7 +306,7 @@ macro_rules! impl_codec_for_sequence {
                     }
                     let (head, t) = tail.split_at_mut(element_size);
                     tail = t;
-                    inner.push(T::from_bytes_unchecked(head));
+                    inner.push(T::from_bytes_(head)?);
                 }
                 Ok(Self(inner, PhantomData))
             }