From cfc6a6691482c761cb6c29412e23b5ae12f4c1c4 Mon Sep 17 00:00:00 2001
From: Eitan Seri-Levi <eserilev@ucsc.edu>
Date: Wed, 24 Jul 2024 06:28:42 -0700
Subject: [PATCH] update alloy-primitives package

add generic  alloy types encode/decode
---
 ssz/Cargo.toml          |  4 ++--
 ssz/src/decode/impls.rs | 36 +++++++++++++++++++++++++----------
 ssz/src/encode/impls.rs | 42 ++++++++++++++++++++++++++++++++++++-----
 3 files changed, 65 insertions(+), 17 deletions(-)

diff --git a/ssz/Cargo.toml b/ssz/Cargo.toml
index 9bc831e..934145e 100644
--- a/ssz/Cargo.toml
+++ b/ssz/Cargo.toml
@@ -14,11 +14,11 @@ categories = ["cryptography::cryptocurrencies"]
 name = "ssz"
 
 [dev-dependencies]
-alloy-primitives = { version = "0.7.0", features = ["getrandom"] }
+alloy-primitives = { version = "0.7.7", features = ["getrandom"] }
 ethereum_ssz_derive = { version = "0.5.4", path = "../ssz_derive" }
 
 [dependencies]
-alloy-primitives = "0.7.0"
+alloy-primitives = "0.7.7"
 smallvec = { version = "1.6.1", features = ["const_generics"] }
 itertools = "0.10.3"
 
diff --git a/ssz/src/decode/impls.rs b/ssz/src/decode/impls.rs
index 08746bf..9b57745 100644
--- a/ssz/src/decode/impls.rs
+++ b/ssz/src/decode/impls.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::decode::try_from_iter::{TryCollect, TryFromIter};
-use alloy_primitives::{Address, B256, U128, U256};
+use alloy_primitives::{Address, Bytes, FixedBytes, U128, U256};
 use core::num::NonZeroUsize;
 use itertools::process_results;
 use smallvec::SmallVec;
@@ -296,24 +296,27 @@ impl Decode for Address {
     }
 }
 
-impl Decode for B256 {
+impl<const N: usize> Decode for FixedBytes<N> {
     fn is_ssz_fixed_len() -> bool {
         true
     }
 
     fn ssz_fixed_len() -> usize {
-        32
+        N
     }
 
     fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
-        let len = bytes.len();
-        let expected = <Self as Decode>::ssz_fixed_len();
-
-        if len != expected {
-            Err(DecodeError::InvalidByteLength { len, expected })
-        } else {
-            Ok(B256::from_slice(bytes))
+        if bytes.len() != N {
+            return Err(DecodeError::InvalidByteLength {
+                len: bytes.len(),
+                expected: N,
+            });
         }
+
+        let mut fixed_array = [0u8; N];
+        fixed_array.copy_from_slice(bytes);
+
+        Ok(Self(fixed_array))
     }
 }
 
@@ -338,6 +341,18 @@ impl Decode for U256 {
     }
 }
 
+impl Decode for Bytes {
+    #[inline]
+    fn is_ssz_fixed_len() -> bool {
+        false
+    }
+
+    #[inline]
+    fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
+        Ok(bytes.to_vec().into())
+    }
+}
+
 impl Decode for U128 {
     fn is_ssz_fixed_len() -> bool {
         true
@@ -527,6 +542,7 @@ pub fn decode_list_of_variable_length_items<T: Decode, Container: TryFromIter<T>
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloy_primitives::B256;
 
     // Note: decoding of valid bytes is generally tested "indirectly" in the `/tests` dir, by
     // encoding then decoding the element.
diff --git a/ssz/src/encode/impls.rs b/ssz/src/encode/impls.rs
index f0c1a66..c691164 100644
--- a/ssz/src/encode/impls.rs
+++ b/ssz/src/encode/impls.rs
@@ -1,5 +1,5 @@
 use super::*;
-use alloy_primitives::{Address, B256, U128, U256};
+use alloy_primitives::{Address, Bytes, FixedBytes, U128, U256};
 use core::num::NonZeroUsize;
 use smallvec::SmallVec;
 use std::collections::{BTreeMap, BTreeSet};
@@ -427,21 +427,52 @@ impl Encode for Address {
     }
 }
 
-impl Encode for B256 {
+impl<const N: usize> Encode for FixedBytes<N> {
+    #[inline]
     fn is_ssz_fixed_len() -> bool {
         true
     }
 
+    #[inline]
+    fn ssz_bytes_len(&self) -> usize {
+        N
+    }
+
+    #[inline]
     fn ssz_fixed_len() -> usize {
-        32
+        N
+    }
+
+    #[inline]
+    fn ssz_append(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.0);
+    }
+
+    #[inline]
+    fn as_ssz_bytes(&self) -> Vec<u8> {
+        self.0.to_vec()
+    }
+}
+
+impl Encode for Bytes {
+    #[inline]
+    fn is_ssz_fixed_len() -> bool {
+        false
     }
 
+    #[inline]
     fn ssz_bytes_len(&self) -> usize {
-        32
+        self.0.len()
     }
 
+    #[inline]
     fn ssz_append(&self, buf: &mut Vec<u8>) {
-        buf.extend_from_slice(self.as_slice());
+        buf.extend_from_slice(&self.0);
+    }
+
+    #[inline]
+    fn as_ssz_bytes(&self) -> Vec<u8> {
+        self.0.to_vec()
     }
 }
 
@@ -510,6 +541,7 @@ impl_encodable_for_u8_array!(48);
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloy_primitives::B256;
 
     #[test]
     fn vec_of_u8() {