Update sv2-tp-crates

protocols/v2/binary-sv2/binary-sv2/src/lib.rs

@@ -18,11 +18,14 @@ pub fn clone_message<T: Serialize>(_: T) -> T {
 
 #[cfg(not(feature = "with_serde"))]
 pub fn u256_from_int<V: Into<u64>>(value: V) -> U256<'static> {
+    // initialize u256 as a bytes vec of len 24
     let mut u256 = vec![0_u8; 24];
     let val: u64 = value.into();
     for v in &(val.to_le_bytes()) {
+        // add 8 bytes to u256
         u256.push(*v)
     }
+    // Always safe cause u256 is 24 + 8 (32) bytes
     let u256: U256 = u256.try_into().unwrap();
     u256
 }
@@ -31,33 +34,6 @@ pub fn u256_from_int<V: Into<u64>>(value: V) -> U256<'static> {
 mod test {
     use super::*;
 
-    mod test_bytes {
-        use super::*;
-        use core::convert::TryInto;
-
-        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
-        struct Test<'decoder> {
-            #[cfg_attr(feature = "with_serde", serde(borrow))]
-            a: Bytes<'decoder>,
-        }
-
-        #[test]
-        fn test_struct() {
-            let mut bytes = [98; 890];
-            let a: Bytes = (&mut bytes[..]).try_into().unwrap();
-            let expected = Test { a };
-
-            #[cfg(not(feature = "with_serde"))]
-            let mut bytes = to_bytes(expected.clone()).unwrap();
-            #[cfg(feature = "with_serde")]
-            let mut bytes = to_bytes(&expected.clone()).unwrap();
-
-            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
-
-            assert_eq!(deserialized, expected);
-        }
-    }
-
     mod test_struct {
         use super::*;
         use core::convert::TryInto;

protocols/v2/binary-sv2/no-serde-sv2/codec/src/codec/decodable.rs

@@ -1,9 +1,10 @@
 use crate::{
     codec::{GetSize, SizeHint},
-    datatypes::{Bytes, Signature, Sv2DataType, B016M, B0255, B032, B064K, U24, U256},
+    datatypes::{Signature, Sv2DataType, U32AsRef, B016M, B0255, B032, B064K, U24, U256},
     Error,
 };
 use alloc::vec::Vec;
+use std::convert::TryFrom;
 #[cfg(not(feature = "no_std"))]
 use std::io::{Cursor, Read};
 
@@ -55,13 +56,13 @@ pub enum PrimitiveMarker {
     U256,
     Signature,
     U32,
+    U32AsRef,
     F32,
     U64,
     B032,
     B0255,
     B064K,
     B016M,
-    Bytes,
 }
 
 /// Passed to a decoder to define the structure of the data to be decoded
@@ -84,13 +85,13 @@ pub enum DecodablePrimitive<'a> {
     U256(U256<'a>),
     Signature(Signature<'a>),
     U32(u32),
+    U32AsRef(U32AsRef<'a>),
     F32(f32),
     U64(u64),
     B032(B032<'a>),
     B0255(B0255<'a>),
     B064K(B064K<'a>),
     B016M(B016M<'a>),
-    Bytes(Bytes<'a>),
 }
 
 /// Used to contrustuct messages is returned by the decoder
@@ -101,6 +102,7 @@ pub enum DecodableField<'a> {
 }
 
 impl SizeHint for PrimitiveMarker {
+    // PrimitiveMarker need introspection to return a size hint. This method is not implementeable
     fn size_hint(_data: &[u8], _offset: usize) -> Result<usize, Error> {
         unimplemented!()
     }
@@ -114,18 +116,19 @@ impl SizeHint for PrimitiveMarker {
             Self::U256 => U256::size_hint(data, offset),
             Self::Signature => Signature::size_hint(data, offset),
             Self::U32 => u32::size_hint(data, offset),
+            Self::U32AsRef => U32AsRef::size_hint(data, offset),
             Self::F32 => f32::size_hint(data, offset),
             Self::U64 => u64::size_hint(data, offset),
             Self::B032 => B032::size_hint(data, offset),
             Self::B0255 => B0255::size_hint(data, offset),
             Self::B064K => B064K::size_hint(data, offset),
             Self::B016M => B016M::size_hint(data, offset),
-            Self::Bytes => Bytes::size_hint(data, offset),
         }
     }
 }
 
 impl SizeHint for FieldMarker {
+    // FieldMarker need introspection to return a size hint. This method is not implementeable
     fn size_hint(_data: &[u8], _offset: usize) -> Result<usize, Error> {
         unimplemented!()
     }
@@ -145,6 +148,7 @@ impl SizeHint for FieldMarker {
 }
 
 impl SizeHint for Vec<FieldMarker> {
+    // FieldMarker need introspection to return a size hint. This method is not implementeable
     fn size_hint(_data: &[u8], _offset: usize) -> Result<usize, Error> {
         unimplemented!()
     }
@@ -165,12 +169,18 @@ impl From<PrimitiveMarker> for FieldMarker {
     }
 }
 
-impl From<Vec<FieldMarker>> for FieldMarker {
-    fn from(mut v: Vec<FieldMarker>) -> Self {
+impl TryFrom<Vec<FieldMarker>> for FieldMarker {
+    type Error = crate::Error;
+
+    fn try_from(mut v: Vec<FieldMarker>) -> Result<Self, crate::Error> {
         match v.len() {
-            0 => panic!("TODO"),
-            1 => v.pop().unwrap(),
-            _ => FieldMarker::Struct(v),
+            // It shouldn't be possible to call this function with a void Vec but for safety
+            // reasons it is implemented with TryFrom and not From if needed should be possible
+            // to use From and just panic
+            0 => Err(crate::Error::VoidFieldMarker),
+            // This is always safe: if v.len is 1 pop can not fail
+            1 => Ok(v.pop().unwrap()),
+            _ => Ok(FieldMarker::Struct(v)),
         }
     }
 }
@@ -196,6 +206,9 @@ impl PrimitiveMarker {
                 DecodablePrimitive::Signature(Signature::from_bytes_unchecked(&mut data[offset..]))
             }
             Self::U32 => DecodablePrimitive::U32(u32::from_bytes_unchecked(&mut data[offset..])),
+            Self::U32AsRef => {
+                DecodablePrimitive::U32AsRef(U32AsRef::from_bytes_unchecked(&mut data[offset..]))
+            }
             Self::F32 => DecodablePrimitive::F32(f32::from_bytes_unchecked(&mut data[offset..])),
             Self::U64 => DecodablePrimitive::U64(u64::from_bytes_unchecked(&mut data[offset..])),
             Self::B032 => DecodablePrimitive::B032(B032::from_bytes_unchecked(&mut data[offset..])),
@@ -208,9 +221,6 @@ impl PrimitiveMarker {
             Self::B016M => {
                 DecodablePrimitive::B016M(B016M::from_bytes_unchecked(&mut data[offset..]))
             }
-            Self::Bytes => {
-                DecodablePrimitive::Bytes(Bytes::from_bytes_unchecked(&mut data[offset..]))
-            }
         }
     }
 
@@ -226,13 +236,15 @@ impl PrimitiveMarker {
                 reader,
             )?)),
             Self::U32 => Ok(DecodablePrimitive::U32(u32::from_reader_(reader)?)),
+            Self::U32AsRef => Ok(DecodablePrimitive::U32AsRef(U32AsRef::from_reader_(
+                reader,
+            )?)),
             Self::F32 => Ok(DecodablePrimitive::F32(f32::from_reader_(reader)?)),
             Self::U64 => Ok(DecodablePrimitive::U64(u64::from_reader_(reader)?)),
             Self::B032 => Ok(DecodablePrimitive::B032(B032::from_reader_(reader)?)),
             Self::B0255 => Ok(DecodablePrimitive::B0255(B0255::from_reader_(reader)?)),
             Self::B064K => Ok(DecodablePrimitive::B064K(B064K::from_reader_(reader)?)),
             Self::B016M => Ok(DecodablePrimitive::B016M(B016M::from_reader_(reader)?)),
-            Self::Bytes => Ok(DecodablePrimitive::Bytes(Bytes::from_reader_(reader)?)),
         }
     }
 }
@@ -247,13 +259,13 @@ impl<'a> GetSize for DecodablePrimitive<'a> {
             DecodablePrimitive::U256(v) => v.get_size(),
             DecodablePrimitive::Signature(v) => v.get_size(),
             DecodablePrimitive::U32(v) => v.get_size(),
+            DecodablePrimitive::U32AsRef(v) => v.get_size(),
             DecodablePrimitive::F32(v) => v.get_size(),
             DecodablePrimitive::U64(v) => v.get_size(),
             DecodablePrimitive::B032(v) => v.get_size(),
             DecodablePrimitive::B0255(v) => v.get_size(),
             DecodablePrimitive::B064K(v) => v.get_size(),
             DecodablePrimitive::B016M(v) => v.get_size(),
-            DecodablePrimitive::Bytes(v) => v.get_size(),
         }
     }
 }

protocols/v2/binary-sv2/no-serde-sv2/codec/src/codec/encodable.rs

@@ -1,6 +1,6 @@
 use crate::{
     codec::GetSize,
-    datatypes::{Bytes, Signature, Sv2DataType, B016M, B0255, B032, B064K, U24, U256},
+    datatypes::{Signature, Sv2DataType, U32AsRef, B016M, B0255, B032, B064K, U24, U256},
     Error,
 };
 use alloc::vec::Vec;
@@ -42,13 +42,13 @@ pub enum EncodablePrimitive<'a> {
     U256(U256<'a>),
     Signature(Signature<'a>),
     U32(u32),
+    U32AsRef(U32AsRef<'a>),
     F32(f32),
     U64(u64),
     B032(B032<'a>),
     B0255(B0255<'a>),
     B064K(B064K<'a>),
     B016M(B016M<'a>),
-    Bytes(Bytes<'a>),
 }
 
 impl<'a> EncodablePrimitive<'a> {
@@ -62,13 +62,13 @@ impl<'a> EncodablePrimitive<'a> {
             Self::U256(v) => v.to_slice(dst),
             Self::Signature(v) => v.to_slice(dst),
             Self::U32(v) => v.to_slice(dst),
+            Self::U32AsRef(v) => v.to_slice(dst),
             Self::F32(v) => v.to_slice(dst),
             Self::U64(v) => v.to_slice(dst),
             Self::B032(v) => v.to_slice(dst),
             Self::B0255(v) => v.to_slice(dst),
             Self::B064K(v) => v.to_slice(dst),
             Self::B016M(v) => v.to_slice(dst),
-            Self::Bytes(v) => v.to_slice(dst),
         }
     }
 
@@ -83,13 +83,13 @@ impl<'a> EncodablePrimitive<'a> {
             Self::U256(v) => v.to_writer_(writer),
             Self::Signature(v) => v.to_writer_(writer),
             Self::U32(v) => v.to_writer_(writer),
+            Self::U32AsRef(v) => v.to_writer_(writer),
             Self::F32(v) => v.to_writer_(writer),
             Self::U64(v) => v.to_writer_(writer),
             Self::B032(v) => v.to_writer_(writer),
             Self::B0255(v) => v.to_writer_(writer),
             Self::B064K(v) => v.to_writer_(writer),
             Self::B016M(v) => v.to_writer_(writer),
-            Self::Bytes(v) => v.to_writer_(writer),
         }
     }
 }
@@ -105,13 +105,13 @@ impl<'a> GetSize for EncodablePrimitive<'a> {
             Self::U256(v) => v.get_size(),
             Self::Signature(v) => v.get_size(),
             Self::U32(v) => v.get_size(),
+            Self::U32AsRef(v) => v.get_size(),
             Self::F32(v) => v.get_size(),
             Self::U64(v) => v.get_size(),
             Self::B032(v) => v.get_size(),
             Self::B0255(v) => v.get_size(),
             Self::B064K(v) => v.get_size(),
             Self::B016M(v) => v.get_size(),
-            Self::Bytes(v) => v.get_size(),
         }
     }
 }