fixes

Author: jialinli98

ethereum/circuits/lib/src/fixtures/mainnet/cancun/approve/transaction.nr

@@ -198,7 +198,7 @@ global storage_data: [u8; 1000] = [
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 ];
-global transaction: TxPartial<1000> = TxPartial {
+pub(crate) global transaction: TxPartial<1000> = TxPartial {
     nonce: 0,
     gas_limit: 48948,
     to: Option::some([

ethereum/circuits/lib/src/fixtures/mainnet/london/vitalik_balance/header.nr

@@ -1,7 +1,7 @@
 use crate::{header::BlockHeaderPartial, misc::types::Bytes32};
 
 global number: u64 = 12965000;
-global hash: Bytes32 = [
+pub(crate) global hash: Bytes32 = [
     0x9b, 0x83, 0xc1, 0x2c, 0x69, 0xed, 0xb7, 0x4f, 0x6c, 0x8d, 0xd5, 0xd0, 0x52, 0x76, 0x5c, 0x1a,
     0xdf, 0x94, 0x0e, 0x32, 0x0b, 0xd1, 0x29, 0x16, 0x96, 0xe6, 0xfa, 0x07, 0x82, 0x9e, 0xee, 0x71,
 ];

ethereum/circuits/lib/src/receipt.nr

@@ -76,8 +76,8 @@ impl From<TxReceiptPartial> for ForeignCallTxReceiptPartial {
 type ProofInputSerialized<let LEN: u32> = [Field; LEN];
 
 pub struct TxReceiptWithinBlock {
-    receipt: TxReceiptPartial,
-    block_hash: Bytes32,
+    pub(crate) receipt: TxReceiptPartial,
+    pub(crate) block_hash: Bytes32,
 }
 
 pub fn get_receipt(chain_id: u32, block_number: u64, tx_idx: Field) -> TxReceiptWithinBlock {

ethereum/circuits/lib/src/serde.nr

@@ -23,27 +23,27 @@ pub(crate) trait Serde<let LEN: u32> {
     fn deserialize(data: [Field; LEN]) -> Self;
 }
 
-pub(crate) global U128_SERIALIZED_LEN: u32 = 2;
+pub(crate) global U128_SERIALIZED_LEN: u32 = 1;
 
 impl Serde<U128_SERIALIZED_LEN> for u128 {
     fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {
-        [self.lo, self.hi]
+        [self as Field]
     }
 
     fn deserialize(data: [Field; U128_SERIALIZED_LEN]) -> Self {
-        U128 { lo: data[0], hi: data[1] }
+        data[0] as u128
     }
 }
 
-pub(crate) global U256_SERIALIZED_LEN: u32 = 4;
+pub(crate) global U256_SERIALIZED_LEN: u32 = 2;
 
 impl Serde<U256_SERIALIZED_LEN> for U256 {
     fn serialize(self) -> [Field; U256_SERIALIZED_LEN] {
-        [self.low.lo, self.low.hi, self.high.lo, self.high.hi]
+        [self.low as Field, self.high as Field]
     }
 
     fn deserialize(data: [Field; U256_SERIALIZED_LEN]) -> Self {
-        U256 { low: U128 { lo: data[0], hi: data[1] }, high: U128 { lo: data[2], hi: data[3] } }
+        U256 { low: data[0] as u128, high: data[1] as u128 }
     }
 }
 
@@ -105,7 +105,7 @@ impl Serde<STORAGE_BLOCK_LEN> for StorageWithinBlock<1> {
         data.extend_from_array(self.block_hash.serialize());
         data.extend_from_array(self.account.serialize());
         data.extend_from_array(self.values[0].serialize());
-        data.storage
+        data.storage()
     }
 
     fn deserialize(data: [Field; STORAGE_BLOCK_LEN]) -> Self {
@@ -128,7 +128,7 @@ pub fn serialize_state_nodes(
     for i in 0..MAX_ACCOUNT_DEPTH_NO_LEAF_M {
         data.extend_from_array(nodes[i].serialize());
     }
-    data.storage
+    data.storage()
 }
 
 pub fn deserialize_state_nodes(
@@ -151,7 +151,7 @@ impl Serde<STATE_PROOF_LEN_M> for Proof<MAX_ACCOUNT_DEPTH_NO_LEAF_M, MAX_ACCOUNT
         data.extend_from_array(serialize_state_nodes(self.nodes));
         data.extend_from_array(self.leaf.serialize());
         data.push(self.depth as Field);
-        data.storage
+        data.storage()
     }
 
     fn deserialize(data: [Field; STATE_PROOF_LEN_M]) -> Self {
@@ -195,7 +195,7 @@ pub fn serialize_storage_nodes(
     for i in 0..MAX_STORAGE_DEPTH_NO_LEAF_M {
         data.extend_from_array(nodes[i].serialize());
     }
-    data.storage
+    data.storage()
 }
 
 pub fn deserialize_storage_nodes(
@@ -218,7 +218,7 @@ impl Serde<STORAGE_PROOF_LEN_M> for Proof<MAX_STORAGE_DEPTH_NO_LEAF_M, MAX_STORA
         data.extend_from_array(serialize_storage_nodes(self.nodes));
         data.extend_from_array(self.leaf.serialize());
         data.push(self.depth as Field);
-        data.storage
+        data.storage()
     }
 
     fn deserialize(data: [Field; STORAGE_PROOF_LEN_M]) -> Self {
@@ -239,7 +239,7 @@ impl Serde<STORAGE_PROOF_INPUT_LEN_M> for ProofInput<STORAGE_MAX_PREFIXED_KEY_NI
         data.extend_from_array(self.key.serialize());
         data.extend_from_array(self.value.serialize());
         data.extend_from_array(self.proof.serialize());
-        data.storage
+        data.storage()
     }
 
     fn deserialize(data: [Field; STORAGE_PROOF_INPUT_LEN_M]) -> Self {
@@ -262,7 +262,7 @@ pub fn serialize_receipt_nodes(
     for i in 0..RECEIPT_MAX_DEPTH_NO_LEAF {
         data.extend_from_array(nodes[i].serialize());
     }
-    data.storage
+    data.storage()
 }
 
 pub fn deserialize_receipt_nodes(
@@ -285,7 +285,7 @@ impl Serde<RECEIPT_PROOF_LEN_M> for Proof<RECEIPT_MAX_DEPTH_NO_LEAF, RECEIPT_MAX
         data.extend_from_array(serialize_receipt_nodes(self.nodes));
         data.extend_from_array(self.leaf.serialize());
         data.push(self.depth as Field);
-        data.storage
+        data.storage()
     }
 
     fn deserialize(data: [Field; RECEIPT_PROOF_LEN_M]) -> Self {
@@ -308,7 +308,7 @@ impl Serde<RECEIPT_PROOF_INPUT_LEN_M> for ProofInput<RECEIPT_MAX_PREFIXED_KEY_NI
         data.extend_from_array(self.key.serialize());
         data.extend_from_array(self.value.serialize());
         data.extend_from_array(self.proof.serialize());
-        data.storage
+        data.storage()
     }
 
     fn deserialize(data: [Field; RECEIPT_PROOF_INPUT_LEN_M]) -> Self {

ethereum/circuits/lib/src/serde_test.nr

@@ -1,43 +1,37 @@
 mod U128_ {
 
-    use crate::serde::U128_SERIALIZED_LEN;
+    use crate::serde::{Serde, U128_SERIALIZED_LEN};
 
     #[test]
     fn simple() {
         let value: u128 = 100;
         let serialized: [Field; U128_SERIALIZED_LEN] = value.serialize();
 
-        assert_eq(serialized[0], value.lo);
-        assert_eq(serialized[1], value.hi);
-        assert_eq(U128::deserialize(serialized), value);
+        assert_eq(serialized[0] as u128, value);
+        assert_eq(u128::deserialize(serialized), value);
     }
 }
 
 mod U256 {
+    use crate::serde::Serde;
     use crate::serde::U256_SERIALIZED_LEN;
     use crate::uint256::U256;
 
-    global u128_number = 0x10000000000000000000000000000000;
-    global u64_value = 0x1000000000000000;
+    global u128_number: u128 = 0x10000000000000000000000000000000;
 
     #[test]
     fn simple() {
-        let value = U256::new(
-            U128::from_integer(u128_number),
-            U128::from_integer(u128_number),
-        );
+        let value = U256::new(u128_number, u128_number);
         let serialized: [Field; U256_SERIALIZED_LEN] = value.serialize();
 
-        assert_eq(serialized[0], 0);
-        assert_eq(serialized[1], u64_value);
-        assert_eq(serialized[2], 0);
-        assert_eq(serialized[3], u64_value);
+        assert_eq(serialized[0] as u128, u128_number);
+        assert_eq(serialized[1] as u128, u128_number);
         assert_eq(U256::deserialize(serialized), value);
     }
 }
 
 mod u8_array {
-    use crate::misc::types::{Address, ADDRESS_LENGTH, Bytes32, BYTES32_LENGTH};
+    use crate::{misc::types::{Address, ADDRESS_LENGTH, Bytes32, BYTES32_LENGTH}, serde::Serde};
 
     #[test]
     fn bytes32() {
@@ -63,6 +57,7 @@ mod account {
     use crate::fixtures::mainnet::london::vitalik_balance::account::account;
     use crate::misc::arrays::sub_array_equals;
     use crate::serde::ACCOUNT_LEN;
+    use crate::serde::Serde;
 
     #[test]
     fn simple() {
@@ -81,6 +76,7 @@ mod account_within_block {
     use crate::fixtures::mainnet::london::vitalik_balance::{account::account, header::hash};
     use crate::misc::arrays::sub_array_equals;
     use crate::serde::{ACCOUNT_BLOCK_LEN, ACCOUNT_LEN};
+    use crate::serde::Serde;
 
     #[test]
     fn simple() {
@@ -104,6 +100,7 @@ mod storage_within_block {
     };
     use crate::misc::{arrays::sub_array_equals, types::BYTES32_LENGTH};
     use crate::serde::{ACCOUNT_LEN, STORAGE_BLOCK_LEN};
+    use crate::serde::Serde;
 
     #[test]
     fn simple() {
@@ -130,6 +127,7 @@ mod nodes {
     use crate::merkle_patricia_proofs::proof::MAX_NODE_LEN;
     use crate::misc::arrays::sub_array_equals;
     use crate::serde::{deserialize_receipt_nodes, serialize_receipt_nodes};
+    use crate::serde::Serde;
 
     #[test]
     fn simple() {
@@ -151,7 +149,8 @@ mod proof {
     use crate::merkle_patricia_proofs::proof::Proof;
     use crate::misc::arrays::sub_array_equals;
     use crate::receipt::MAX_DEPTH_NO_LEAF as RECEIPT_MAX_DEPTH_NO_LEAF;
-    use crate::serde::{RECEIPT_MAX_LEAF_LEN_M, RECEIPT_NODES_LEN, Serde, serialize_receipt_nodes};
+    use crate::receipt::MAX_LEAF_LEN_M as RECEIPT_MAX_LEAF_LEN_M;
+    use crate::serde::{RECEIPT_NODES_LEN, Serde, serialize_receipt_nodes};
 
     #[test]
     fn simple() {

ethereum/circuits/lib/src/transaction.nr

@@ -45,8 +45,7 @@ pub(crate) struct ForeignCallTransaction<let MAX_DATA_LEN: u32> {
     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) value: u128,
     pub(crate) data: [u8; MAX_DATA_LEN],
     pub(crate) data_len: u32,
     pub(crate) v: u8, // ECDSA recovery id
@@ -68,8 +67,7 @@ impl<let MAX_DATA_LEN: u32> From<TxPartial<MAX_DATA_LEN>> for ForeignCallTransac
             gas_limit: tx.gas_limit,
             to: tx.to.unwrap_or(std::mem::zeroed()),
             to_is_some: tx.to.is_some(),
-            value_hi: tx.value.hi as u64,
-            value_lo: tx.value.lo as u64,
+            value: tx.value,
             data,
             data_len: tx.data.len(),
             v: tx.v,
@@ -87,7 +85,7 @@ impl<let MAX_DATA_LEN: u32> From<ForeignCallTransaction<MAX_DATA_LEN>> for TxPar
             nonce: tx.nonce,
             gas_limit: tx.gas_limit,
             to: make_option(tx.to, tx.to_is_some),
-            value: U128::from_u64s_be(tx.value_hi as u64, tx.value_lo as u64),
+            value: tx.value,
             data,
             v: tx.v,
             r: tx.r,

ethereum/circuits/lib/src/transaction_test.nr

@@ -22,8 +22,7 @@ fn into_foreign_call_transaction_test() {
     assert_eq(foreign_call_transaction.to_is_some, true);
     assert_eq(foreign_call_transaction.to, transaction.to.expect(f"To is missing"));
 
-    assert_eq(foreign_call_transaction.value_hi, transaction.value.hi as u64);
-    assert_eq(foreign_call_transaction.value_lo, transaction.value.lo as u64);
+    assert_eq(foreign_call_transaction.value, transaction.value);
 
     assert_eq(foreign_call_transaction.data, [1, 2, 3, 4, 5, 0, 0, 0]);
     assert_eq(foreign_call_transaction.data_len, 5);

ethereum/circuits/lib/src/uint256.nr

@@ -6,24 +6,24 @@ use dep::std::ops::Add;
 global uint128_overflow_value: Field = 340282366920938463463374607431768211456; // 2^128
 
 pub(crate) struct U256 {
-    high: u128,
-    low: u128,
+    pub(crate) high: u128,
+    pub(crate) low: u128,
 }
 
 impl U256 {
-    fn new(high: u128, low: u128) -> Self {
+    pub(crate) fn new(high: u128, low: u128) -> Self {
         Self { high, low }
     }
 
-    fn zero() -> Self {
+    pub(crate) fn zero() -> Self {
         Self { high: 0, low: 0 }
     }
 
-    fn one() -> Self {
+    pub(crate) fn one() -> Self {
         Self { high: 0, low: 0 }
     }
 
-    fn from_field(field: Field) -> Self {
+    pub(crate) fn from_field(field: Field) -> Self {
         U256::from(field_to_bytes32(field))
     }
 }