[Feature] Fixed-size unsigned integer target types

beacon-light-client/plonky2/crates/circuit/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition.workspace = true
 
 [dependencies]
+circuit_derive = { path = "../circuit_derive" }
 plonky2 = { git = "https://github.com/metacraft-labs/plonky2" }
 plonky2_crypto = { git = "https://github.com/metacraft-labs/plonky2-crypto" }
 starky = { git = "https://github.com/metacraft-labs/plonky2" }
@@ -12,3 +13,4 @@ itertools = "0.10.5"
 deriving_via = "1.6.1"
 serde = "1.0.164"
 serde-big-array = "0.5.1"
+primitive-types = "0.12.2"

beacon-light-client/plonky2/crates/circuit/src/lib.rs

@@ -6,9 +6,12 @@ pub mod array;
 pub mod circuit;
 pub mod circuit_builder_extensions;
 pub mod public_inputs;
+pub mod serde;
 pub mod serde_circuit_target;
 pub mod set_witness;
+pub mod ssz_hash_tree_root;
 pub mod target_primitive;
+pub mod targets;
 pub mod to_targets;
 
 pub use add_virtual_target::AddVirtualTarget;
@@ -20,6 +23,7 @@ pub use public_inputs::{
 };
 pub use serde_circuit_target::SerdeCircuitTarget;
 pub use set_witness::SetWitness;
+pub use ssz_hash_tree_root::SSZHashTreeRoot;
 pub use target_primitive::TargetPrimitive;
 pub use to_targets::ToTargets;
 

beacon-light-client/plonky2/crates/circuit/src/serde.rs

@@ -0,0 +1,73 @@
+pub mod serde_u64_str {
+    use core::fmt;
+
+    use serde::{de::Visitor, Deserializer, Serializer};
+
+    pub fn serialize<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&value.to_string())
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<u64, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Vis;
+
+        impl<'de> Visitor<'de> for Vis {
+            type Value = u64;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a string")
+            }
+
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(v.parse().unwrap())
+            }
+        }
+
+        deserializer.deserialize_str(Vis)
+    }
+}
+
+pub mod serde_u128_str {
+    use core::fmt;
+
+    use serde::{de::Visitor, Deserializer, Serializer};
+
+    pub fn serialize<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&value.to_string())
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<u128, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Vis;
+
+        impl<'de> Visitor<'de> for Vis {
+            type Value = u128;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a string")
+            }
+
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(v.parse().unwrap())
+            }
+        }
+
+        deserializer.deserialize_str(Vis)
+    }
+}

beacon-light-client/plonky2/crates/circuit/src/serde_circuit_target.rs

@@ -4,7 +4,7 @@ use plonky2::{
     plonk::{circuit_data::VerifierCircuitTarget, proof::ProofWithPublicInputsTarget},
     util::serialization::{Buffer, IoResult, Read, Write},
 };
-use plonky2_crypto::biguint::BigUintTarget;
+use plonky2_crypto::{biguint::BigUintTarget, u32::arithmetic_u32::U32Target};
 use starky::proof::{StarkOpeningSetTarget, StarkProofTarget, StarkProofWithPublicInputsTarget};
 
 use crate::{Circuit, PublicInputsTargetReadable};
@@ -118,8 +118,24 @@ impl<T: SerdeCircuitTarget + std::fmt::Debug, const N: usize> SerdeCircuitTarget
     }
 }
 
+impl SerdeCircuitTarget for U32Target {
+    fn serialize(&self) -> IoResult<Vec<u8>> {
+        let mut buffer: Vec<u8> = Vec::new();
+        buffer.write_target(self.0)?;
+        Ok(buffer)
+    }
+
+    fn deserialize(buffer: &mut Buffer) -> IoResult<Self>
+    where
+        Self: Sized,
+    {
+        let target = buffer.read_target()?;
+        Ok(Self(target))
+    }
+}
+
 impl SerdeCircuitTarget for BigUintTarget {
-    fn serialize(&self) -> plonky2::util::serialization::IoResult<Vec<u8>> {
+    fn serialize(&self) -> IoResult<Vec<u8>> {
         assert_eq!(self.num_limbs(), 2);
 
         let mut buffer: Vec<u8> = Vec::new();
@@ -128,9 +144,7 @@ impl SerdeCircuitTarget for BigUintTarget {
         Ok(buffer)
     }
 
-    fn deserialize(
-        buffer: &mut plonky2::util::serialization::Buffer,
-    ) -> plonky2::util::serialization::IoResult<Self>
+    fn deserialize(buffer: &mut Buffer) -> IoResult<Self>
     where
         Self: Sized,
     {

beacon-light-client/plonky2/crates/circuit/src/ssz_hash_tree_root.rs

@@ -0,0 +1,32 @@
+use itertools::Itertools;
+use plonky2::{
+    field::extension::Extendable, hash::hash_types::RichField, iop::target::BoolTarget,
+    plonk::circuit_builder::CircuitBuilder,
+};
+
+use crate::targets::uint::Uint64Target;
+
+pub trait SSZHashTreeRoot<F: RichField + Extendable<D>, const D: usize> {
+    fn ssz_hash_tree_root(self, builder: &mut CircuitBuilder<F, D>) -> [BoolTarget; 256];
+}
+
+impl<F: RichField + Extendable<D>, const D: usize> SSZHashTreeRoot<F, D> for Uint64Target {
+    fn ssz_hash_tree_root(self, builder: &mut CircuitBuilder<F, D>) -> [BoolTarget; 256] {
+        let _false = builder._false();
+
+        self.to_le_bytes(builder)
+            .into_iter()
+            .pad_using(256, |_| _false)
+            .collect_vec()
+            .try_into()
+            .unwrap()
+    }
+}
+
+impl<F: RichField + Extendable<D>, const D: usize> SSZHashTreeRoot<F, D> for BoolTarget {
+    fn ssz_hash_tree_root(self, builder: &mut CircuitBuilder<F, D>) -> [BoolTarget; 256] {
+        let mut ssz_leaf = [builder._false(); 256];
+        ssz_leaf[7] = self;
+        ssz_leaf
+    }
+}

beacon-light-client/plonky2/crates/circuit/src/targets/mod.rs

@@ -0,0 +1 @@
+pub mod uint;