fix

Author: jialinli98

ethereum/circuits/lib/src/uint256.nr

@@ -1,11 +1,6 @@
-use crate::misc::arrays::memcpy_up_to_length;
-use crate::misc::bytes32::field_to_bytes32;
 use crate::misc::types::Bytes32;
 use dep::bignum::bignum::BigNum;
 use dep::bignum::U256 as u256;
-use dep::std::ops::Add;
-
-global uint128_overflow_value: Field = 340282366920938463463374607431768211456; // 2^128
 
 pub fn from(bytes: Bytes32) -> u256 {
     let mut bytes33 = [0; 33];

ethereum/circuits/lib/src/uint256_test.nr

@@ -1,13 +1,11 @@
 mod from_bytes32 {
-    use crate::uint256::{from, from_field};
+    use crate::uint256::from;
     use dep::bignum::bignum::BigNum;
     use dep::bignum::U256;
 
-    global high: u128 = 0x10000000000000000000000000000000;
-    global low: u128 = 0;
     global limit_u256: U256 = U256::zero() - U256::one();
 
-    global big_number: U256 = from_field(0x10000000000000000000000000000000);
+    global big_number: U256 = U256::modulus().udiv(U256::from(16));
 
     #[test]
     fn zero() {
@@ -18,7 +16,7 @@ mod from_bytes32 {
     #[test]
     fn success() {
         let mut bytes = [0x00; 32];
-        bytes[31] = 0x10;
+        bytes[0] = 0x10;
         assert_eq(from(bytes), big_number);
     }
 
@@ -30,13 +28,11 @@ mod from_bytes32 {
 }
 
 mod into_bytes32 {
-    use crate::uint256::{from_field, into};
+    use crate::uint256::into;
     use dep::bignum::bignum::BigNum;
     use dep::bignum::U256;
-    global high: u128 = 0x10000000000000000000000000000000;
-    global low: u128 = 0;
 
-    global big_number: U256 = from_field(0x10000000000000000000000000000000);
+    global big_number: U256 = U256::modulus().udiv(U256::from(16));
     global limit_u256: U256 = U256::zero() - U256::one();
 
     #[test]
@@ -48,7 +44,7 @@ mod into_bytes32 {
     #[test]
     fn success() {
         let mut bytes = [0x00; 32];
-        bytes[31] = 0x10;
+        bytes[0] = 0x10;
         assert_eq(into(big_number), bytes);
     }
 

ethereum/circuits/lib/src/verifiers/receipt/rlp.nr

@@ -14,13 +14,11 @@ pub(crate) fn assert_receipt_rlp_equals<let MAX_ENCODED_LEN: u32>(
     receipt_rlp: Fragment<MAX_ENCODED_LEN, u8>,
     receipt: TxReceiptPartial,
 ) {
-    println(f"receipt_rlp: {receipt_rlp}");
     let receipt_rlp_list: RlpList<RECEIPT_FIELDS_COUNT> = decode_list(receipt_rlp);
     assert(
         receipt_rlp_list.len() == RECEIPT_FIELDS_COUNT,
         "Invalid number of fields in receipt RLP",
     );
-    //println(f"receipt_rlp_list: {receipt_rlp_list}");
     if (is_pre_byzantium) {
         receipt_rlp_list.get(STATE_ROOT_INDEX).assert_eq_bytes32(
             "State root",

vlayer/ethereum/circuits/lib/src/slot.nr

@@ -17,9 +17,14 @@ pub(crate) fn dynamic_array(slot: U256, size: Field, index: Field) -> U256 {
 }
 
 pub(crate) fn dynamic_array_with_precalculated_slot(slot: U256, size: Field, index: Field) -> U256 {
-    slot + from_field(size * index)
+    let product = from_field(size * index);
+    let sum = slot + product;
+    assert(sum >= slot, "Attempt to add with overflow");
+    sum
 }
 
 pub(crate) fn struct_slot(slot: U256, offset: Field) -> U256 {
-    slot + from_field(offset)
+    let sum = slot + from_field(offset);
+    assert(sum >= slot, "Attempt to add with overflow");
+    sum
 }

vlayer/ethereum/circuits/lib/src/slot_test.nr

@@ -87,7 +87,7 @@ mod dynamic_array {
         assert_eq(expected_slot, dynamic_array(slot, 2, 7));
     }
 
-    #[test(should_fail_with = "attempt to add with overflow")]
+    #[test(should_fail_with = "Attempt to add with overflow")]
     fn fail_overflow() {
         let slot = from_field(6);
         let _ = dynamic_array(slot, 2, MAX_FIELD_VALUE);
@@ -121,7 +121,7 @@ mod dynamic_array_with_precalculated_slot {
         assert_eq(expected_slot, dynamic_array_with_precalculated_slot(slot, 10, 1_000_000_000));
     }
 
-    #[test(should_fail_with = "attempt to add with overflow")]
+    #[test(should_fail_with = "Attempt to add with overflow")]
     fn fail_overflow() {
         let slot = from([0xfe; 32]);
         let _ = dynamic_array_with_precalculated_slot(slot, 2, MAX_FIELD_VALUE);
@@ -142,7 +142,7 @@ mod struct_slot {
         assert_eq(expected_slot, struct_slot(slot, 256));
     }
 
-    #[test(should_fail_with = "attempt to add with overflow")]
+    #[test(should_fail_with = "Attempt to add with overflow")]
     fn overflow() {
         let slot = from([0xff; 32]);
         let _ = struct_slot(slot, 256);