replace u256

Author: jialinli98

ethereum/circuits/lib/Nargo.toml

@@ -5,4 +5,5 @@ authors = ["Arkadiusz Konior, Marek Kirejczyk"]
 compiler_version = ">=0.30.0"
 
 [dependencies]
-keccak256 = {tag = "v0.1.1", git = "https://github.com/noir-lang/keccak256" }
+keccak256 = {tag = "v0.1.1", git = "https://github.com/noir-lang/keccak256" }
+bignum = {tag = "v0.8.3", git = "https://github.com/noir-lang/noir-bignum" }

ethereum/circuits/lib/src/serde.nr

@@ -15,7 +15,8 @@ use crate::receipt::{
     MAX_PREFIXED_KEY_NIBBLE_LEN as RECEIPT_MAX_PREFIXED_KEY_NIBBLE_LEN,
     MAX_VALUE_LEN_M as RECEIPT_MAX_VALUE_LEN_M,
 };
-use crate::uint256::U256;
+use dep::bignum::bignum::BigNum;
+use dep::bignum::U256 as u256;
 
 pub trait Serde<let LEN: u32> {
     fn serialize(self) -> [Field; LEN];
@@ -34,15 +35,15 @@ impl Serde<U128_SERIALIZED_LEN> for u128 {
     }
 }
 
-pub(crate) global U256_SERIALIZED_LEN: u32 = 2;
+pub(crate) global u256_SERIALIZED_LEN: u32 = 3;
 
-impl Serde<U256_SERIALIZED_LEN> for U256 {
-    fn serialize(self) -> [Field; U256_SERIALIZED_LEN] {
-        [self.low as Field, self.high as Field]
+impl Serde<u256_SERIALIZED_LEN> for u256 {
+    fn serialize(self) -> [Field; u256_SERIALIZED_LEN] {
+        self.get_limbs().map(|x: u128| x as Field)
     }
 
-    fn deserialize(data: [Field; U256_SERIALIZED_LEN]) -> Self {
-        U256 { low: data[0] as u128, high: data[1] as u128 }
+    fn deserialize(data: [Field; u256_SERIALIZED_LEN]) -> Self {
+        u256::from_limbs(data.map(|x: Field| x as u128))
     }
 }
 

ethereum/circuits/lib/src/serde_test.nr

@@ -14,18 +14,19 @@ mod U128_ {
 
 mod U256 {
     use crate::serde::Serde;
-    use crate::serde::U256_SERIALIZED_LEN;
-    use crate::uint256::U256;
+    use crate::serde::u256_SERIALIZED_LEN;
+    use crate::uint256::from_field;
+    use dep::bignum::bignum::BigNum;
+    use dep::bignum::U256;
 
-    global u128_number: u128 = 0x10000000000000000000000000000000;
+    global u128_number: Field = 0x10000000000000000000000000000000;
 
     #[test]
     fn simple() {
-        let value = U256::new(u128_number, u128_number);
-        let serialized: [Field; U256_SERIALIZED_LEN] = value.serialize();
-
-        assert_eq(serialized[0] as u128, u128_number);
-        assert_eq(serialized[1] as u128, u128_number);
+        let value = from_field(u128_number);
+        let serialized: [Field; u256_SERIALIZED_LEN] = value.serialize();
+        let s = serialized.map(|x: Field| x as u128);
+        assert_eq(U256::from_limbs(s), value);
         assert_eq(U256::deserialize(serialized), value);
     }
 }

ethereum/circuits/lib/src/uint256.nr

@@ -1,86 +1,34 @@
 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 struct U256 {
-    pub(crate) high: u128,
-    pub(crate) low: u128,
-}
-
-impl U256 {
-    pub fn new(high: u128, low: u128) -> Self {
-        Self { high, low }
-    }
-
-    pub fn zero() -> Self {
-        Self { high: 0, low: 0 }
-    }
-
-    pub fn one() -> Self {
-        Self { high: 0, low: 1 }
-    }
-
-    pub fn from_field(field: Field) -> Self {
-        U256::from(field_to_bytes32(field))
-    }
-}
-
-impl From<Bytes32> for U256 {
-    fn from(bytes: Bytes32) -> Self {
-        let mut high_bytes = [0; 16];
-        memcpy_up_to_length(&mut high_bytes, bytes, 16, 16);
-        let high = Field::from_le_bytes::<16>(high_bytes) as u128;
-
-        let mut low_bytes = [0; 16];
-        memcpy_up_to_length(&mut low_bytes, bytes, 0, 16);
-        let low = Field::from_le_bytes::<16>(low_bytes) as u128;
-
-        U256::new(high, low)
+pub fn from(bytes: Bytes32) -> u256 {
+    let mut bytes33 = [0; 33];
+    for i in 0..32 {
+        bytes33[i + 1] = bytes[i];
     }
+    u256::from_be_bytes(bytes33)
 }
 
-impl Into<Bytes32> for U256 {
-    fn into(self) -> Bytes32 {
-        let mut bytes = [0; 32];
-        memcpy_up_to_length(&mut bytes, (self.low as Field).to_le_bytes::<16>(), 0, 16);
-
-        let high_bytes = (self.high as Field).to_le_bytes::<16>();
-        for i in 0..16 {
-            bytes[i + 16] = high_bytes[i];
-        }
-
-        bytes
+pub fn into(u256: u256) -> Bytes32 {
+    let bytes = u256.to_be_bytes();
+    let mut bytes32 = [0; 32];
+    for i in 0..32 {
+        bytes32[i] = bytes[i + 1];
     }
+    bytes32
 }
 
-impl Eq for U256 {
-    fn eq(self, other: U256) -> bool {
-        (self.high == other.high) & (self.low == other.low)
-    }
-}
-
-impl Add for U256 {
-    fn add(self, other: Self) -> Self {
-        let lo: Field = self.low as Field + other.low as Field;
-
-        let mut low = 0;
-        let mut carry = 0;
-        if (lo.lt(uint128_overflow_value)) {
-            low = lo;
-        } else {
-            low = lo - uint128_overflow_value;
-            carry = 1;
-        }
-
-        let hi: Field = self.high as Field + other.high as Field + carry;
-        assert(hi.lt(uint128_overflow_value), "attempt to add with overflow");
-
-        let high = hi as u128;
-        let low = low as u128;
-
-        Self { high, low }
+pub fn from_field(field: Field) -> u256 {
+    let bytes = field.to_be_bytes::<32>();
+    let mut bytes33 = [0; 33];
+    for i in 0..32 {
+        bytes33[i + 1] = bytes[i];
     }
+    u256::from_be_bytes(bytes33)
 }

ethereum/circuits/lib/src/uint256_test.nr

@@ -1,135 +1,60 @@
-use crate::uint256::U256;
-
-global high: u128 = 0x10000000000000000000000000000000;
-global low: u128 = 0;
-
-global big_number: U256 = U256::new(high, low);
-
-#[test]
-fn success() {
-    assert_eq(big_number.high, high);
-    assert_eq(big_number.low, low);
-}
-
-#[test]
-fn new() {
-    let big_number = U256::new(high, low);
-    assert_eq(big_number.high, high);
-    assert_eq(big_number.low, low);
-}
-
-#[test]
-fn zero_and_one() {
-    let zero = U256::zero();
-    assert_eq(zero.high, 0);
-    assert_eq(zero.low, 0);
-
-    let one = U256::one();
-    assert_eq(one.high, 0);
-    assert_eq(one.low, 1);
-}
-
 mod from_bytes32 {
-    use crate::uint256::U256;
+    use crate::uint256::{from, from_field};
+    use dep::bignum::bignum::BigNum;
+    use dep::bignum::U256;
+
     global high: u128 = 0x10000000000000000000000000000000;
     global low: u128 = 0;
-    global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
+    global limit_u256: U256 = U256::zero() - U256::one();
 
-    global big_number: U256 = U256::new(high, low);
-    global limit_u256: U256 = U256::new(limit, limit);
+    global big_number: U256 = from_field(0x10000000000000000000000000000000);
 
     #[test]
     fn zero() {
         let bytes = [0x00; 32];
-        assert_eq(U256::from(bytes), U256::zero());
+        assert_eq(from(bytes), U256::zero());
     }
 
     #[test]
     fn success() {
         let mut bytes = [0x00; 32];
         bytes[31] = 0x10;
-        assert_eq(U256::from(bytes), big_number);
+        assert_eq(from(bytes), big_number);
     }
 
     #[test]
     fn u256_limit() {
         let bytes = [0xff; 32];
-        assert_eq(U256::from(bytes), limit_u256);
+        assert_eq(from(bytes), limit_u256);
     }
 }
 
 mod into_bytes32 {
-    use crate::uint256::U256;
+    use crate::uint256::{from_field, into};
+    use dep::bignum::bignum::BigNum;
+    use dep::bignum::U256;
     global high: u128 = 0x10000000000000000000000000000000;
     global low: u128 = 0;
-    global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
-    global big_number: U256 = U256::new(high, low);
-    global limit_u256: U256 = U256::new(limit, limit);
+    global big_number: U256 = from_field(0x10000000000000000000000000000000);
+    global limit_u256: U256 = U256::zero() - U256::one();
 
     #[test]
     fn zero() {
         let bytes = [0x00; 32];
-        assert_eq(U256::into(U256::zero()), bytes);
+        assert_eq(into(U256::zero()), bytes);
     }
 
     #[test]
     fn success() {
         let mut bytes = [0x00; 32];
         bytes[31] = 0x10;
-        assert_eq(U256::into(big_number), bytes);
+        assert_eq(into(big_number), bytes);
     }
 
     #[test]
     fn u256_limit() {
         let bytes = [0xff; 32];
-        assert_eq(U256::into(limit_u256), bytes);
-    }
-}
-
-#[test]
-fn eq() {
-    assert_eq(big_number, big_number);
-
-    let big_number2 = U256::new(high, low);
-    assert_eq(big_number, big_number2);
-}
-
-#[test]
-fn not_eq() {
-    let big_number2 = U256 { high, low: high };
-    assert(big_number != big_number2);
-
-    let big_number3 = U256 { high: low, low };
-    assert(big_number != big_number3);
-}
-
-mod trait_add {
-    use crate::uint256::U256;
-    global high: u128 = 0x10000000000000000000000000000000;
-    global low: u128 = 0;
-    global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
-
-    global big_number: U256 = U256::new(high, low);
-    global limit_u256: U256 = U256::new(limit, limit);
-
-    #[test]
-    fn sum() {
-        let sum = big_number + big_number;
-
-        assert_eq(sum, U256 { high: 0x20000000000000000000000000000000, low });
-    }
-
-    #[test]
-    fn sum_with_carry() {
-        let big_number = U256 { high, low: limit };
-        let sum = big_number + U256::one();
-
-        assert_eq(sum, U256 { high: 0x10000000000000000000000000000001, low });
-    }
-
-    #[test(should_fail_with = "attempt to add with overflow")]
-    fn sum_overflow() {
-        let _ = limit_u256 + U256::one();
+        assert_eq(into(limit_u256), bytes);
     }
 }

vlayer/ethereum/circuits/lib/Nargo.toml

@@ -5,4 +5,5 @@ compiler_version = ">=0.30.0"
 
 [dependencies]
 ethereum = { path = "../../../../ethereum/circuits/lib" }
-keccak256 = {tag = "v0.1.1", git = "https://github.com/noir-lang/keccak256" }
+keccak256 = {tag = "v0.1.1", git = "https://github.com/noir-lang/keccak256" }
+bignum = {tag = "v0.8.3", git = "https://github.com/noir-lang/noir-bignum" }

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

@@ -1,10 +1,11 @@
+use dep::bignum::U256;
 use dep::ethereum::{
     account_with_storage::get_account_with_storage,
     misc::{
         arrays::subarray_inferred_len,
         types::{Address, ADDRESS_LENGTH, Bytes32, BYTES32_LENGTH},
     },
-    uint256::U256,
+    uint256::into,
 };
 
 pub struct ERC721Token {
@@ -20,12 +21,8 @@ pub trait ERC721 {
 impl ERC721 for ERC721Token {
     fn get_owner(self, token_id: Bytes32, block_number: u64) -> Address {
         let storage_key = (self.token_id_to_slot)(token_id);
-        let account = get_account_with_storage(
-            self.chain_id,
-            block_number,
-            self.address,
-            U256::into(storage_key),
-        );
+        let account =
+            get_account_with_storage(self.chain_id, block_number, self.address, into(storage_key));
         subarray_inferred_len(account.values[0], BYTES32_LENGTH - ADDRESS_LENGTH)
     }
 }

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

@@ -2,7 +2,7 @@ pub mod mainnet {
     use crate::chain_id;
     use crate::nft::ERC721Token;
     use crate::slot::{dynamic_array_with_precalculated_slot, mapping, struct_slot};
-    use dep::ethereum::uint256::U256;
+    use dep::ethereum::uint256::{from, from_field};
     use dep::std::field::bytes32_to_field;
 
     pub fn BORED_APE_YACHT_CLUB() -> ERC721Token {
@@ -13,7 +13,7 @@ pub mod mainnet {
             ],
             token_id_to_slot: |token_id| {
                 let BORED_APE_YACHT_CLUB_MAX_TOKEN_ID: u32 = 9999;
-                let BORED_APE_YACHT_CLUB_TOKEN_OWNERS_INNER_ENTRIES_SLOT = U256::from([
+                let BORED_APE_YACHT_CLUB_TOKEN_OWNERS_INNER_ENTRIES_SLOT = from([
                     0x40, 0x57, 0x87, 0xfa, 0x12, 0xa8, 0x23, 0xe0, 0xf2, 0xb7, 0x63, 0x1c, 0xc4,
                     0x1b, 0x3b, 0xa8, 0x82, 0x8b, 0x33, 0x21, 0xca, 0x81, 0x11, 0x11, 0xfa, 0x75,
                     0xcd, 0x3a, 0xa3, 0xbb, 0x5a, 0xce,
@@ -43,7 +43,7 @@ pub mod mainnet {
             ],
             token_id_to_slot: |token_id| {
                 let CRYPTO_PUNK_MAX_TOKEN_ID: u32 = 9999;
-                let CRYPTO_PUNK_TOKEN_OWNERS_INNER_ENTRIES_SLOT = U256::from_field(10);
+                let CRYPTO_PUNK_TOKEN_OWNERS_INNER_ENTRIES_SLOT = from_field(10);
 
                 assert(
                     bytes32_to_field(token_id) as u32 <= CRYPTO_PUNK_MAX_TOKEN_ID,