fixes

Author: jialinli98

ethereum/circuits/lib/src/misc.nr

@@ -9,6 +9,6 @@ mod fragment_test;
 mod fragment_int_test;
 pub mod types;
 pub(crate) mod option;
-pub(crate) mod bytes32;
+pub mod bytes32;
 mod bytes32_test;
 pub(crate) mod iterator;

ethereum/circuits/lib/src/transaction.nr

@@ -41,17 +41,17 @@ impl<let MAX_DATA_LEN: u32> Eq for TxPartial<MAX_DATA_LEN> {
 }
 
 pub(crate) struct ForeignCallTransaction<let MAX_DATA_LEN: u32> {
-    nonce: u64,
-    gas_limit: u64,
-    to: Address,
-    to_is_some: bool,
-    value_hi: u64,
-    value_lo: u64,
-    data: [u8; MAX_DATA_LEN],
-    data_len: u32,
-    v: u8, // ECDSA recovery id
-    r: Bytes32, // ECDSA signature part
-    s: Bytes32, // ECDSA signature part
+    pub(crate) nonce: u64,
+    pub(crate) gas_limit: u64,
+    pub(crate) to: Address,
+    pub(crate) to_is_some: bool,
+    pub(crate) value_hi: u64,
+    pub(crate) value_lo: u64,
+    pub(crate) data: [u8; MAX_DATA_LEN],
+    pub(crate) data_len: u32,
+    pub(crate) v: u8, // ECDSA recovery id
+    pub(crate) r: Bytes32, // ECDSA signature part
+    pub(crate) s: Bytes32, // ECDSA signature part
 }
 
 impl<let MAX_DATA_LEN: u32> From<TxPartial<MAX_DATA_LEN>> for ForeignCallTransaction<MAX_DATA_LEN> {
@@ -99,8 +99,8 @@ impl<let MAX_DATA_LEN: u32> From<ForeignCallTransaction<MAX_DATA_LEN>> for TxPar
 type ProofInputSerialized<let LEN: u32> = [Field; LEN];
 
 pub struct TransactionWithinBlock<let MAX_DATA_LEN: u32> {
-    transaction: TxPartial<MAX_DATA_LEN>,
-    block_hash: Bytes32,
+    pub(crate) transaction: TxPartial<MAX_DATA_LEN>,
+    pub(crate) block_hash: Bytes32,
 }
 
 pub fn get_transaction<let MAX_DATA_LEN: u32>(

ethereum/circuits/lib/src/transaction_int_test.nr

@@ -17,7 +17,7 @@ use crate::fixtures::mainnet::{
         transaction_proof::proof_input_serialized as another_proof_input_serialized,
     },
 };
-use crate::transaction::{get_transaction, TransactionWithinBlock};
+use crate::transaction::{get_transaction, TransactionWithinBlock, TxPartial};
 use dep::std::test::OracleMock;
 
 global MAX_DATA_LEN: u32 = 1000;
@@ -37,7 +37,22 @@ fn get_transaction_success() {
         get_transaction(ETHEREUM_MAINNET_ID, number, tx_idx);
 
     assert_eq(transaction_within_block.block_hash, block_header_partial.hash);
-    assert_eq(transaction_within_block.transaction, foreign_call_transaction.into());
+    // Convert transaction from TxPartial<68> to TxPartial<1000> by creating a new one with extended data
+    let mut data_extended: BoundedVec<u8, MAX_DATA_LEN> = BoundedVec::new();
+    for i in 0..transaction.data.len() {
+        data_extended.push(transaction.data.get(i));
+    }
+    let transaction_1000 = TxPartial::<MAX_DATA_LEN> {
+        nonce: transaction.nonce,
+        gas_limit: transaction.gas_limit,
+        to: transaction.to,
+        value: transaction.value,
+        data: data_extended,
+        v: transaction.v,
+        r: transaction.r,
+        s: transaction.s,
+    };
+    assert_eq(transaction_within_block.transaction, transaction_1000);
 }
 
 #[test(should_fail_with = "Block number does not match the argument")]

ethereum/circuits/lib/src/uint256.nr

@@ -32,11 +32,11 @@ 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 = from_le_bytes(high_bytes);
+        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 = u256::from_le_bytes(low_bytes);
+        let low = Field::from_le_bytes::<16>(low_bytes) as u128;
 
         U256::new(high, low)
     }
@@ -45,9 +45,9 @@ impl From<Bytes32> for U256 {
 impl Into<Bytes32> for U256 {
     fn into(self) -> Bytes32 {
         let mut bytes = [0; 32];
-        memcpy_up_to_length(&mut bytes, self.low.to_le_bytes(), 0, 16);
+        memcpy_up_to_length(&mut bytes, (self.low as Field).to_le_bytes::<16>(), 0, 16);
 
-        let high_bytes = self.high.to_le_bytes();
+        let high_bytes = (self.high as Field).to_le_bytes::<16>();
         for i in 0..16 {
             bytes[i + 16] = high_bytes[i];
         }
@@ -64,21 +64,22 @@ impl Eq for U256 {
 
 impl Add for U256 {
     fn add(self, other: Self) -> Self {
-        let lo: Field = self.low.to_integer() + other.low.to_integer();
+        let lo: Field = self.low as Field + other.low as Field;
 
-        let mut low = U128::from_integer(0);
+        let mut low = 0;
         let mut carry = 0;
         if (lo.lt(uint128_overflow_value)) {
-            low = U128::from_integer(lo);
+            low = lo;
         } else {
-            low = U128::from_integer(lo - uint128_overflow_value);
+            low = lo - uint128_overflow_value;
             carry = 1;
         }
 
-        let hi: Field = self.high.to_integer() + other.high.to_integer() + carry;
+        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 }
     }

ethereum/circuits/lib/src/uint256_test.nr

@@ -1,10 +1,10 @@
 use crate::uint256::U256;
 
-global high = U128::from_integer(0x10000000000000000000000000000000);
-global low = U128::zero();
-global limit = U128::from_integer(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+global high: u128 = 0x10000000000000000000000000000000;
+global low: u128 = 0;
+global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
-global big_number = U256 { high, low };
+global big_number: U256 = U256::new(high, low);
 
 #[test]
 fn success() {
@@ -22,22 +22,22 @@ fn new() {
 #[test]
 fn zero_and_one() {
     let zero = U256::zero();
-    assert_eq(zero.high, U128::zero());
-    assert_eq(zero.low, U128::zero());
+    assert_eq(zero.high, 0);
+    assert_eq(zero.low, 0);
 
     let one = U256::one();
-    assert_eq(one.high, U128::zero());
-    assert_eq(one.low, U128::one());
+    assert_eq(one.high, 0);
+    assert_eq(one.low, 0);
 }
 
 mod from_bytes32 {
     use crate::uint256::U256;
-    global high = U128::from_integer(0x10000000000000000000000000000000);
-    global low = U128::zero();
-    global limit = U128::from_integer(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    global high: u128 = 0x10000000000000000000000000000000;
+    global low: u128 = 0;
+    global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
-    global big_number = U256 { high, low };
-    global limit_u256 = U256 { high: limit, low: limit };
+    global big_number: U256 = U256::new(high, low);
+    global limit_u256: U256 = U256::new(limit, limit);
 
     #[test]
     fn zero() {
@@ -61,12 +61,12 @@ mod from_bytes32 {
 
 mod into_bytes32 {
     use crate::uint256::U256;
-    global high = U128::from_integer(0x10000000000000000000000000000000);
-    global low = U128::zero();
-    global limit = U128::from_integer(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    global high: u128 = 0x10000000000000000000000000000000;
+    global low: u128 = 0;
+    global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
-    global big_number = U256 { high, low };
-    global limit_u256 = U256 { high: limit, low: limit };
+    global big_number: U256 = U256::new(high, low);
+    global limit_u256: U256 = U256::new(limit, limit);
 
     #[test]
     fn zero() {
@@ -107,26 +107,26 @@ fn not_eq() {
 
 mod trait_add {
     use crate::uint256::U256;
-    global high = U128::from_integer(0x10000000000000000000000000000000);
-    global low = U128::zero();
-    global limit = U128::from_integer(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    global high: u128 = 0x10000000000000000000000000000000;
+    global low: u128 = 0;
+    global limit: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
-    global big_number = U256 { high, low };
-    global limit_u256 = U256 { high: limit, low: limit };
+    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: U128::from_integer(0x20000000000000000000000000000000), low });
+        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: U128::from_integer(0x10000000000000000000000000000001), low });
+        assert_eq(sum, U256 { high: 0x10000000000000000000000000000001, low });
     }
 
     #[test(should_fail_with = "attempt to add with overflow")]

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

@@ -1,8 +1,8 @@
-mod token;
+pub(crate) mod token;
 mod token_int_test;
-mod slot;
+pub(crate) mod slot;
 mod slot_test;
-mod token_list;
-mod chain_id;
-mod nft;
+pub(crate) mod token_list;
+pub(crate) mod chain_id;
+pub(crate) mod nft;
 mod nft_list;