final touches

Author: olehmisar

ethereum/circuits/lib/README.md

@@ -24,25 +24,25 @@ If you decide to use our Oracles - you don't need to provide all the data by han
 Here is a list of public functions that you should use if you decide to go the **oracles route**:
 
 ```rust
-pub fn get_header(chain_id: Field, block_number: u32) -> BlockHeaderPartial;
+pub fn get_header(chain_id: Field, block_number: u64) -> BlockHeaderPartial;
 ```
 
 ```rust
-pub fn get_account(chain_id: Field, block_no: u32, address: Address) -> AccountWithinBlock;
+pub fn get_account(chain_id: Field, block_no: u64, address: Address) -> AccountWithinBlock;
 ```
 
 ```rust
-pub fn get_account_with_storage(chain_id: Field, block_number: u32, address: Address, storage_key: Bytes32) -> StorageWithinBlock<1>;
+pub fn get_account_with_storage(chain_id: Field, block_number: u64, address: Address, storage_key: Bytes32) -> StorageWithinBlock<1>;
 ```
 
 ```rust
-pub fn get_receipt<...>(chain_id: Field, block_number: u32, tx_idx: Field, ...) -> TxReceiptWithinBlock;
+pub fn get_receipt<...>(chain_id: Field, block_number: u64, tx_idx: Field, ...) -> TxReceiptWithinBlock;
 ```
 
 ```rust
 pub fn get_transaction<MAX_DATA_LEN, ...>(
     chain_id: Field,
-    block_number: u32,
+    block_number: u64,
     tx_idx: Field,
     ...
 ) -> TransactionWithinBlock<MAX_DATA_LEN>;
@@ -51,7 +51,7 @@ pub fn get_transaction<MAX_DATA_LEN, ...>(
 ```rust
 pub fn get_log<MAX_LOG_DATA_LEN, MAX_LOGS_COUNT>(
     chain_id: Field,
-    block_number: u32,
+    block_number: u64,
     tx_idx: Field,
     log_idx: u32
 ) -> LogWithinBlock<MAX_LOG_DATA_LEN>;

ethereum/circuits/lib/src/account.nr

@@ -1,9 +1,9 @@
 use crate::account_with_storage::Account;
 use crate::header::get_header;
+use crate::merkle_patricia_proofs::proof::ProofInput;
 use crate::misc::types::{Address, Bytes32, BYTES32_LENGTH};
-use crate::verifiers::account::verify_account;
 use crate::serde::Serde;
-use crate::merkle_patricia_proofs::proof::ProofInput;
+use crate::verifiers::account::verify_account;
 
 global MAX_KEY_LEN: u32 = 32;
 global MAX_PREFIXED_KEY_NIBBLE_LEN: u32 = 66; // (MAX_KEY_LEN + 1) * 2
@@ -27,7 +27,7 @@ type AccountWithStateProofM = (Account, ProofInput<MAX_PREFIXED_KEY_NIBBLE_LEN,
 
 type ProofInputSerialized<let LEN: u32> = [Field; LEN];
 
-pub fn get_account(chain_id: Field, block_no: u32, address: Address) -> AccountWithinBlock {
+pub fn get_account(chain_id: Field, block_no: u64, address: Address) -> AccountWithinBlock {
     let (account, state_proof) = get_account_unconstrained_M(chain_id, block_no, address);
     let header = get_header(chain_id, block_no);
     verify_account(address, account, state_proof, header.state_root);
@@ -37,11 +37,15 @@ pub fn get_account(chain_id: Field, block_no: u32, address: Address) -> AccountW
 #[oracle(get_account)]
 unconstrained fn get_account_oracle<let PROOF_INPUT_LEN: u32>(
     _chain_id: Field,
-    _block_no: u32,
-    _address: [u8; 20]
+    _block_no: u64,
+    _address: [u8; 20],
 ) -> (Account, ProofInputSerialized<PROOF_INPUT_LEN>) {}
 
-unconstrained fn get_account_unconstrained_M(chain_id: Field, block_no: u32, address: Address) -> AccountWithStateProofM {
+unconstrained fn get_account_unconstrained_M(
+    chain_id: Field,
+    block_no: u64,
+    address: Address,
+) -> AccountWithStateProofM {
     let (account, proof_input) = get_account_oracle(chain_id, block_no, address);
     let proof_input = Serde::deserialize(proof_input);
 

ethereum/circuits/lib/src/account_with_storage.nr

@@ -1,11 +1,15 @@
-use crate::header::{get_header, BlockHeaderPartial};
-use crate::account::{MAX_ACCOUNT_STATE_LEN, MAX_ACCOUNT_DEPTH_NO_LEAF_M, MAX_ACCOUNT_LEAF_LEN};
-use crate::misc::{types::{Address, Bytes32, BYTES32_LENGTH, HASH_LEN}, bytes::right_pad, fragment::Fragment};
+use crate::account::{MAX_ACCOUNT_DEPTH_NO_LEAF_M, MAX_ACCOUNT_LEAF_LEN, MAX_ACCOUNT_STATE_LEN};
+use crate::header::{BlockHeaderPartial, get_header};
+use crate::merkle_patricia_proofs::proof::ProofInput;
+use crate::misc::{
+    bytes::right_pad,
+    fragment::Fragment,
+    types::{Address, Bytes32, BYTES32_LENGTH, HASH_LEN},
+};
+use crate::rlp::decode::decode_string;
 use crate::serde::Serde;
 use crate::verifiers::account::verify_account;
 use crate::verifiers::storage::verify_storage_values;
-use crate::merkle_patricia_proofs::proof::ProofInput;
-use crate::rlp::decode::decode_string;
 
 use dep::std::hash::keccak256;
 
@@ -17,15 +21,18 @@ global MAX_STORAGE_VALUE_LEN: u32 = 32; // Values taken from storageProofConfig
 global MAX_STORAGE_LEAF_LEN: u32 = 69;
 
 struct Account {
-    nonce: u32,
+    nonce: u64,
     balance: Field,
     storage_root: Bytes32,
     code_hash: Bytes32,
 }
 
 impl Eq for Account {
     fn eq(self, other: Self) -> bool {
-        (self.nonce == other.nonce) & (self.balance == other.balance) & (self.storage_root == other.storage_root) & (self.code_hash == other.code_hash)
+        (self.nonce == other.nonce)
+            & (self.balance == other.balance)
+            & (self.storage_root == other.storage_root)
+            & (self.code_hash == other.code_hash)
     }
 }
 
@@ -34,7 +41,7 @@ impl Eq for Account {
 struct StateAndStorageProofInput {
     account: Account,
     state_proof_input: ProofInput<MAX_PREFIXED_KEY_NIBBLE_LEN, MAX_ACCOUNT_STATE_LEN, MAX_ACCOUNT_DEPTH_NO_LEAF_M, MAX_ACCOUNT_LEAF_LEN>,
-    storage_proof_input: ProofInput<MAX_PREFIXED_KEY_NIBBLE_LEN, MAX_STORAGE_VALUE_LEN, MAX_STORAGE_DEPTH_NO_LEAF_M, MAX_STORAGE_LEAF_LEN>
+    storage_proof_input: ProofInput<MAX_PREFIXED_KEY_NIBBLE_LEN, MAX_STORAGE_VALUE_LEN, MAX_STORAGE_DEPTH_NO_LEAF_M, MAX_STORAGE_LEAF_LEN>,
 }
 
 struct StorageWithinBlock<let N: u32> {
@@ -47,22 +54,26 @@ type ProofInputSerialized<let LEN: u32> = [Field; LEN];
 
 impl Eq for StorageWithinBlock<1> {
     fn eq(self, other: Self) -> bool {
-        (self.block_hash == other.block_hash) & (self.account == other.account) & (self.values[0] == other.values[0])
+        (self.block_hash == other.block_hash)
+            & (self.account == other.account)
+            & (self.values[0] == other.values[0])
     }
 }
 
 fn assert_storage_key_equals(
     storage_key: Bytes32,
-    storage_key_hash: [u8; MAX_PREFIXED_KEY_NIBBLE_LEN]
+    storage_key_hash: [u8; MAX_PREFIXED_KEY_NIBBLE_LEN],
 ) {
     let storage_key_hash_fragment = Fragment::new(
         MAX_PREFIXED_KEY_NIBBLE_LEN - HASH_LEN,
         HASH_LEN,
-        storage_key_hash
+        storage_key_hash,
     );
-    let other_storage_key_hash_fragment = Fragment::from_array(keccak256(storage_key, BYTES32_LENGTH as u32));
+    let other_storage_key_hash_fragment =
+        Fragment::from_array(keccak256(storage_key, BYTES32_LENGTH as u32));
     assert(
-        storage_key_hash_fragment.eq(other_storage_key_hash_fragment), "Storage key does not match the argument"
+        storage_key_hash_fragment.eq(other_storage_key_hash_fragment),
+        "Storage key does not match the argument",
     );
 }
 
@@ -72,7 +83,9 @@ fn get_fragment<let N: u32>(left_padded_value: [u8; N]) -> Fragment<N, u8> {
     Fragment::new(value_offset, value_len, left_padded_value)
 }
 
-fn get_storage_value(rlp_encoded_value: [u8; MAX_STORAGE_VALUE_LEN]) -> [u8; MAX_STORAGE_VALUE_LEN] {
+fn get_storage_value(
+    rlp_encoded_value: [u8; MAX_STORAGE_VALUE_LEN],
+) -> [u8; MAX_STORAGE_VALUE_LEN] {
     let mut storage_value = get_fragment(rlp_encoded_value);
     let rlp_fragment = decode_string(storage_value);
     let rlp_header_len = rlp_fragment.offset;
@@ -89,36 +102,43 @@ fn get_storage_value(rlp_encoded_value: [u8; MAX_STORAGE_VALUE_LEN]) -> [u8; MAX
 
 pub fn get_account_with_storage(
     chain_id: Field,
-    block_number: u32,
+    block_number: u64,
     address: Address,
-    storage_key: Bytes32
+    storage_key: Bytes32,
 ) -> StorageWithinBlock<1> {
-    let BlockHeaderPartial { number: _, hash, state_root, transactions_root: _, receipts_root: _ } = get_header(chain_id, block_number);
-    let StateAndStorageProofInput { account, state_proof_input, storage_proof_input } = get_proof_unconstrained(chain_id, block_number, address, storage_key);
+    let BlockHeaderPartial { number: _, hash, state_root, transactions_root: _, receipts_root: _ } =
+        get_header(chain_id, block_number);
+    let StateAndStorageProofInput { account, state_proof_input, storage_proof_input } =
+        get_proof_unconstrained(chain_id, block_number, address, storage_key);
 
     verify_account(address, account, state_proof_input, state_root);
     verify_storage_values([storage_proof_input], account.storage_root);
 
     assert_storage_key_equals(storage_key, storage_proof_input.key);
 
-    StorageWithinBlock { block_hash: hash, account, values: [get_storage_value(storage_proof_input.value)] }
+    StorageWithinBlock {
+        block_hash: hash,
+        account,
+        values: [get_storage_value(storage_proof_input.value)],
+    }
 }
 
 #[oracle(get_proof)]
 unconstrained fn get_proof_oracle<let STATE_PROOF_INPUT_LEN: u32, let STORAGE_PROOF_INPUT: u32>(
     _chain_id: Field,
-    _block_no: u32,
+    _block_no: u64,
     _address: Address,
-    _storage_key: Bytes32
-) -> (Account, ProofInputSerialized<STATE_PROOF_INPUT_LEN>, ProofInputSerialized<STORAGE_PROOF_INPUT>) {}
+    _storage_key: Bytes32,
+    ) -> (Account, ProofInputSerialized<STATE_PROOF_INPUT_LEN>, ProofInputSerialized<STORAGE_PROOF_INPUT>) {}
 
 unconstrained fn get_proof_unconstrained(
     chain_id: Field,
-    block_no: u32,
+    block_no: u64,
     address: Address,
-    storage_key: Bytes32
+    storage_key: Bytes32,
 ) -> StateAndStorageProofInput {
-    let (account, state_proof_input, storage_proof_input) = get_proof_oracle(chain_id, block_no, address, storage_key);
+    let (account, state_proof_input, storage_proof_input) =
+        get_proof_oracle(chain_id, block_no, address, storage_key);
     let state_proof_input = Serde::deserialize(state_proof_input);
     let storage_proof_input = Serde::deserialize(storage_proof_input);
 

ethereum/circuits/lib/src/account_with_storage_recursive.nr

@@ -1,7 +1,7 @@
 use crate::account_with_storage::StorageWithinBlock;
-use crate::misc::{fragment::Fragment, types::{Address, Bytes32, ADDRESS_LENGTH, BYTES32_LENGTH}};
+use crate::misc::{fragment::Fragment, types::{Address, ADDRESS_LENGTH, Bytes32, BYTES32_LENGTH}};
 use crate::serde::STORAGE_BLOCK_LEN;
-use dep::std::{verify_proof, mem::zeroed};
+use dep::std::{mem::zeroed, verify_proof};
 
 struct RecursiveProof {
     key_hash: Field,
@@ -13,11 +13,16 @@ global NUM_PUBLIC_INPUTS: u32 = 1 + 1 + ADDRESS_LENGTH + BYTES32_LENGTH + STORAG
 
 pub fn get_account_with_storage_recursive(
     chain_id: Field,
-    block_number: u32,
+    block_number: u64,
     address: Address,
-    storage_key: Bytes32
+    storage_key: Bytes32,
 ) -> StorageWithinBlock<1> {
-    let (storage_within_block, RecursiveProof {key_hash, verification_key, proof}) = get_account_with_storage_recursive_unconstrained(chain_id, block_number, address, storage_key);
+    let (storage_within_block, RecursiveProof { key_hash, verification_key, proof }) = get_account_with_storage_recursive_unconstrained(
+        chain_id,
+        block_number,
+        address,
+        storage_key,
+    );
 
     let mut public_inputs: Fragment<NUM_PUBLIC_INPUTS, Field> = Fragment::empty();
     public_inputs.push_back(chain_id);
@@ -30,7 +35,7 @@ pub fn get_account_with_storage_recursive(
         verification_key,
         proof,
         public_inputs.to_array::<NUM_PUBLIC_INPUTS>(),
-        key_hash
+        key_hash,
     );
 
     storage_within_block
@@ -39,18 +44,19 @@ pub fn get_account_with_storage_recursive(
 #[oracle(get_storage_recursive)]
 unconstrained fn get_account_with_storage_recursive_oracle(
     chain_id: Field,
-    block_number: u32,
+    block_number: u64,
     address: Address,
-    storage_key: Bytes32
+    storage_key: Bytes32,
 ) -> ([Field; STORAGE_BLOCK_LEN], RecursiveProof) {}
 
 unconstrained fn get_account_with_storage_recursive_unconstrained(
     chain_id: Field,
-    block_number: u32,
+    block_number: u64,
     address: Address,
-    storage_key: Bytes32
+    storage_key: Bytes32,
 ) -> (StorageWithinBlock<1>, RecursiveProof) {
-    let (return_value_serialized, proof) = get_account_with_storage_recursive_oracle(chain_id, block_number, address, storage_key);
+    let (return_value_serialized, proof) =
+        get_account_with_storage_recursive_oracle(chain_id, block_number, address, storage_key);
     let return_value = StorageWithinBlock::deserialize(return_value_serialized);
     (return_value, proof)
 }

ethereum/circuits/lib/src/header.nr

@@ -4,7 +4,7 @@ use crate::verifiers::header::verify_header;
 global MAX_HEADER_RLP_LEN: u32 = 708;
 
 struct BlockHeaderPartial {
-    number: u32,
+    number: u64,
     hash: Bytes32,
     state_root: Bytes32,
     transactions_root: Bytes32,
@@ -13,16 +13,16 @@ struct BlockHeaderPartial {
 
 type BlockHeaderRlp = BoundedVec<u8, MAX_HEADER_RLP_LEN>;
 
-pub fn get_header(chain_id: Field, block_number: u32) -> BlockHeaderPartial {
+pub fn get_header(chain_id: Field, block_number: u64) -> BlockHeaderPartial {
     let (block_header_partial, block_header_rlp) = get_header_unconstrained(chain_id, block_number);
     verify_header(chain_id, block_header_partial, block_header_rlp);
     assert(block_header_partial.number == block_number, "Block number does not match the argument");
     block_header_partial
 }
 
 #[oracle(get_header)]
-unconstrained fn get_header_oracle(_chain_id: Field, _block_no: u32) -> (BlockHeaderPartial, BlockHeaderRlp) {}
+unconstrained fn get_header_oracle(_chain_id: Field, _block_no: u64) -> (BlockHeaderPartial, BlockHeaderRlp) {}
 
-unconstrained fn get_header_unconstrained(chain_id: Field, block_no: u32) -> (BlockHeaderPartial, BlockHeaderRlp) {
+unconstrained fn get_header_unconstrained(chain_id: Field, block_no: u64) -> (BlockHeaderPartial, BlockHeaderRlp) {
     get_header_oracle(chain_id, block_no)
 }