chore: consolidate RLP numeric assertions with ToBEBytes trait (#14)

Author: jialinli98

ethereum/circuits/lib/src/rlp/README.md

@@ -59,22 +59,14 @@ Whe working with RLP data - it's a common pattern to have a structure (Tx, Log,
 ```rust
 let rlp = [...];
 let decoded = decode_list(Fragment::from_array(rlp));
-decoded.get(0).assert_eq_u64("nonce", rlp, 0x10);
-decoded.get(1).assert_eq_address("to", rlp, [...]);
+decoded.get(0).assert_eq_value("nonce", rlp, 0x10);
+decoded.get(1).assert_eq_value("to", rlp, [...]);
 ```
 
 ### The full list of those methods:
 
-- `assert_eq_bytes`
-- `assert_eq_bounded_vec`
+- `assert_eq_value`
 - `assert_empty_string`
-- `assert_eq_u1`
-- `assert_eq_u8`
-- `assert_eq_u32`
-- `assert_eq_u64`
-- `assert_eq_u128`
-- `assert_eq_address`
-- `assert_eq_bytes32`
 
 ## RlpList
 

ethereum/circuits/lib/src/rlp/types.nr

@@ -1,13 +1,10 @@
 use crate::misc::bytes::byte_value;
 use crate::misc::fragment::Fragment;
 use crate::misc::types::{Address, Bytes32};
-use crate::verifiers::tx_helpers::idx::u32_to_u8;
-use crate::verifiers::tx_helpers::idx::u64_to_u8;
 
 // Enum for RLP data type
 pub(crate) global STRING: u32 = 0;
 pub(crate) global LIST: u32 = 1;
-
 pub type RlpList<let MAX_FIELDS: u32> = BoundedVec<RlpFragment, MAX_FIELDS>;
 
 pub struct RlpHeader {
@@ -31,112 +28,101 @@ pub struct RlpFragment {
 }
 
 impl RlpFragment {
-    pub(crate) fn assert_eq_bytes<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32, let MAX_VALUE_LEN: u32>(
+    pub fn assert_eq_value<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32, let MAX_VALUE_LEN: u32, VALUE_TYPE>(
         self,
         field_name: str<FIELD_NAME_LEN>,
         rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: Fragment<MAX_VALUE_LEN, u8>,
-    ) {
+        value: VALUE_TYPE,
+    )
+    where
+        VALUE_TYPE: ToRlpFragment<MAX_VALUE_LEN>,
+    {
+        let value_fragment = value.to_fragment();
         assert(self.data_type == STRING, f"{field_name}: Invalid RLP type");
-        assert(self.length == value.length, f"{field_name}: Invalid RLP length");
+        assert(self.length == value_fragment.length, f"{field_name}: Invalid RLP length");
         assert(
-            rlp.subfragment(self.offset, self.length).eq(value),
+            rlp.subfragment(self.offset, self.length).eq(value_fragment),
             f"{field_name}: Invalid RLP value",
         );
     }
 
-    pub(crate) fn assert_eq_bounded_vec<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32, let MAX_VALUE_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: BoundedVec<u8, MAX_VALUE_LEN>,
-    ) {
-        self.assert_eq_bytes(field_name, rlp, Fragment::from_vec(value));
-    }
-
     pub(crate) fn assert_empty_string<let FIELD_NAME_LEN: u32>(
         self,
         field_name: str<FIELD_NAME_LEN>,
     ) {
         assert(self.data_type == STRING, f"{field_name}: Invalid RLP type");
         assert(self.length == 0, f"{field_name}: Expected empty string");
     }
+}
 
-    pub(crate) fn assert_eq_u1<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: u1,
-    ) {
-        self.assert_eq_bytes(field_name, rlp, Fragment::from_array([value as u8]));
+impl Default for RlpFragment {
+    fn default() -> Self {
+        RlpFragment { offset: 0, length: 0, data_type: 0 }
     }
+}
 
-    pub(crate) fn assert_eq_u8<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: u8,
-    ) {
-        self.assert_eq_bounded_vec(field_name, rlp, byte_value([value]));
+impl Eq for RlpFragment {
+    fn eq(self, other: Self) -> bool {
+        (self.offset == other.offset)
+            & (self.length == other.length)
+            & (self.data_type == other.data_type)
     }
+}
 
-    pub(crate) fn assert_eq_u32<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: u32,
-    ) {
-        self.assert_eq_bounded_vec(field_name, rlp, byte_value(u32_to_u8(value)));
+trait ToRlpFragment<let MAX_VALUE_LEN: u32> {
+    fn to_fragment(self) -> Fragment<MAX_VALUE_LEN, u8>;
+}
+
+impl ToRlpFragment<1> for u1 {
+    fn to_fragment(self) -> Fragment<1, u8> {
+        Fragment::from_array([self as u8])
     }
+}
 
-    pub fn assert_eq_u64<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: u64,
-    ) {
-        self.assert_eq_bounded_vec(field_name, rlp, byte_value(u64_to_u8(value)));
+impl ToRlpFragment<1> for u8 {
+    fn to_fragment(self) -> Fragment<1, u8> {
+        Fragment::from_vec(byte_value::<1>([self]))
     }
+}
 
-    pub fn assert_eq_u128<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: u128,
-    ) {
-        let val: Field = value as Field;
-        self.assert_eq_bounded_vec(field_name, rlp, byte_value(val.to_be_bytes::<16>()));
+impl ToRlpFragment<4> for u32 {
+    fn to_fragment(self) -> Fragment<4, u8> {
+        Fragment::from_vec(byte_value::<4>((self as Field).to_be_bytes::<4>()))
     }
+}
 
-    pub(crate) fn assert_eq_address<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: Address,
-    ) {
-        self.assert_eq_bytes(field_name, rlp, Fragment::from_array(value));
+impl ToRlpFragment<8> for u64 {
+    fn to_fragment(self) -> Fragment<8, u8> {
+        Fragment::from_vec(byte_value::<8>((self as Field).to_be_bytes::<8>()))
     }
+}
 
-    pub(crate) fn assert_eq_bytes32<let FIELD_NAME_LEN: u32, let MAX_RLP_LEN: u32>(
-        self,
-        field_name: str<FIELD_NAME_LEN>,
-        rlp: Fragment<MAX_RLP_LEN, u8>,
-        value: Bytes32,
-    ) {
-        self.assert_eq_bytes(field_name, rlp, Fragment::from_array(value));
+impl ToRlpFragment<16> for u128 {
+    fn to_fragment(self) -> Fragment<16, u8> {
+        Fragment::from_vec(byte_value::<16>((self as Field).to_be_bytes::<16>()))
     }
 }
 
-impl Default for RlpFragment {
-    fn default() -> Self {
-        RlpFragment { offset: 0, length: 0, data_type: 0 }
+impl ToRlpFragment<20> for Address {
+    fn to_fragment(self) -> Fragment<20, u8> {
+        Fragment::from_array(self)
     }
 }
 
-impl Eq for RlpFragment {
-    fn eq(self, other: Self) -> bool {
-        (self.offset == other.offset)
-            & (self.length == other.length)
-            & (self.data_type == other.data_type)
+impl ToRlpFragment<32> for Bytes32 {
+    fn to_fragment(self) -> Fragment<32, u8> {
+        Fragment::from_array(self)
+    }
+}
+
+impl<let MAX_FIELD_VALUE_LEN: u32> ToRlpFragment<MAX_FIELD_VALUE_LEN> for BoundedVec<u8, MAX_FIELD_VALUE_LEN> {
+    fn to_fragment(self) -> Fragment<MAX_FIELD_VALUE_LEN, u8> {
+        Fragment::from_vec(self)
+    }
+}
+
+impl<let MAX_FIELD_VALUE_LEN: u32> ToRlpFragment<MAX_FIELD_VALUE_LEN> for Fragment<MAX_FIELD_VALUE_LEN, u8> {
+    fn to_fragment(self) -> Fragment<MAX_FIELD_VALUE_LEN, u8> {
+        self
     }
 }