init

Author: sklppy88

docs/docs/developers/guides/smart_contracts/writing_contracts/how_to_prove_history.md

@@ -4,7 +4,7 @@ sidebar_position: 4
 tags: [contracts]
 ---
 
-The Aztec Protocol uses an append-only Merkle tree to store hashes of the headers of all previous blocks in the chain as its leaves. This is known as the Archive tree. 
+The Aztec Protocol uses an append-only Merkle tree to store hashes of the headers of all previous blocks in the chain as its leaves. This is known as the Archive tree.
 
 This page is a quick introductory guide to creating historical proofs proofs from the archive tree.
 
@@ -37,33 +37,31 @@ Using this library, you can check that specific notes or nullifiers were part of
 
 In general you will likely have the note you want to prove inclusion of. But if you are just experimenting you can create a note with a function like below:
 
-#include_code create_note noir-projects/noir-contracts/contracts/inclusion_proofs_contract/src/main.nr rust
+#include_code create_note noir-projects/noir-contracts/contracts/test_contract/src/main.nr rust
 
 ## Get the note from the PXE
 
 Retrieve the note from the user's PXE.
 
-#include_code get_note_from_pxe noir-projects/noir-contracts/contracts/inclusion_proofs_contract/src/main.nr rust
+#include_code get_note_from_pxe noir-projects/noir-contracts/contracts/test_contract/src/main.nr rust
 
-In this example, the user's notes are stored in a map called `private_values`. We retrieve this map, then select 1 note from it with the value of `1`.
+In this example, the user's notes are stored in a storage_slot that is specified. We look for notes located in this storage_slot and return the ones matched by the getter options.
 
 ## Prove that a note was included in a specified block
 
 To prove that a note existed in a specified block, call `prove_note_inclusion` on the `header` as shown in this example:
 
-#include_code prove_note_inclusion noir-projects/noir-contracts/contracts/inclusion_proofs_contract/src/main.nr rust
-
-Here, if `block_number` exists as an argument, it will prove inclusion in that block. Else, it will use the current block.
+#include_code prove_note_inclusion noir-projects/aztec-nr/aztec/src/history/note_inclusion/test.nr rust
 
 This will only prove the note existed at the specific block number, not whether or not the note has been nullified. You can prove that a note existed and had not been nullified in a specified block by using `prove_note_validity` on the block header which takes the following arguments:
 
-#include_code prove_note_validity noir-projects/noir-contracts/contracts/inclusion_proofs_contract/src/main.nr rust
+#include_code prove_note_validity noir-projects/aztec-nr/aztec/src/history/note_validity/test.nr rust
 
 ## Create a nullifier to prove inclusion of
 
 You can easily nullify a note like so:
 
-#include_code nullify_note noir-projects/noir-contracts/contracts/inclusion_proofs_contract/src/main.nr rust
+#include_code nullify_note noir-projects/noir-contracts/contracts/test_contract/src/main.nr rust
 
 This function gets a note from the PXE and nullifies it with `remove()`.
 
@@ -73,7 +71,7 @@ You can then compute this nullifier with `note.compute_nullifier(&mut context)`.
 
 Call `prove_nullifier_inclusion` on a block header like so:
 
-#include_code prove_nullifier_inclusion noir-projects/noir-contracts/contracts/inclusion_proofs_contract/src/main.nr rust
+#include_code prove_nullifier_inclusion noir-projects/aztec-nr/aztec/src/history/nullifier_inclusion/test.nr rust
 
 It takes the nullifier as an argument.
 

docs/docs/developers/reference/environment_reference/sandbox-reference.md

@@ -133,7 +133,6 @@ EscrowContractArtifact
 FPCContractArtifact
 FeeJuiceContractArtifact
 ImportTestContractArtifact
-InclusionProofsContractArtifact
 LendingContractArtifact
 MultiCallEntrypointContractArtifact
 ParentContractArtifact

noir-projects/aztec-nr/aztec/src/history/contract_inclusion.nr

@@ -3,7 +3,7 @@ use dep::protocol_types::{
     hash::compute_siloed_nullifier,
 };
 
-trait ProveContractDeployment {
+pub trait ProveContractDeployment {
     fn prove_contract_deployment(header: BlockHeader, contract_address: AztecAddress);
 }
 
@@ -17,7 +17,7 @@ impl ProveContractDeployment for BlockHeader {
     }
 }
 
-trait ProveContractNonDeployment {
+pub trait ProveContractNonDeployment {
     fn prove_contract_non_deployment(header: BlockHeader, contract_address: AztecAddress);
 }
 
@@ -33,7 +33,7 @@ impl ProveContractNonDeployment for BlockHeader {
     }
 }
 
-trait ProveContractInitialization {
+pub trait ProveContractInitialization {
     fn prove_contract_initialization(header: BlockHeader, contract_address: AztecAddress);
 }
 
@@ -46,7 +46,7 @@ impl ProveContractInitialization for BlockHeader {
     }
 }
 
-trait ProveContractNonInitialization {
+pub trait ProveContractNonInitialization {
     fn prove_contract_non_initialization(header: BlockHeader, contract_address: AztecAddress);
 }
 

noir-projects/aztec-nr/aztec/src/history/contract_inclusion/test.nr

@@ -0,0 +1,35 @@
+// TODO (12225): the #[aztec] macro currently does not support being used in aztec-nr, hence we cannot do any variation of the below.
+// Replace the hacky work around in noir-contracts/counter_contract which tests the contract inclusion.
+
+// use crate::history::note_inclusion::ProveNoteInclusion;
+// use crate::note::retrieved_note::RetrievedNote;
+// use crate::oracle::execution::get_contract_address;
+// use crate::oracle::random::random;
+// use crate::test::{helpers::test_environment::TestEnvironment, mocks::mock_note::MockNote};
+
+// use dep::protocol_types::address::AztecAddress;
+
+// use crate::macros::aztec;
+
+// #[aztec]
+// pub contract Dummy {
+//     use crate::macros::functions::{initializer, private};
+
+//     #[initializer]
+//     #[private]
+//     fn constructor() {
+//     }
+// }
+
+// unconstrained fn setup() -> AztecAddress {
+//     let mut env = TestEnvironment::new();
+
+//     let initializer = Dummy::interface().constructor();
+// let dummy_contract = env.deploy_self("Dummy").with_private_initializer(initializer);
+
+// env.advance_block_by(1);
+
+// dummy_contract.to_address()
+
+//     AztecAddress::from_field(1)
+// }

noir-projects/aztec-nr/aztec/src/history/mod.nr

@@ -1,6 +1,7 @@
-mod contract_inclusion;
-mod note_inclusion;
-mod note_validity;
-mod nullifier_inclusion;
-mod nullifier_non_inclusion;
-mod public_storage;
+pub mod contract_inclusion;
+pub mod note_inclusion;
+pub mod note_validity;
+pub mod nullifier_inclusion;
+pub mod nullifier_non_inclusion;
+pub mod public_storage;
+mod test;

noir-projects/aztec-nr/aztec/src/history/note_inclusion.nr

@@ -10,6 +10,8 @@ use crate::{
     oracle::get_membership_witness::get_note_hash_membership_witness,
 };
 
+mod test;
+
 trait ProveNoteInclusion {
     fn prove_note_inclusion<Note>(
         header: BlockHeader,

noir-projects/aztec-nr/aztec/src/history/note_inclusion/test.nr

@@ -0,0 +1,20 @@
+use crate::history::{note_inclusion::ProveNoteInclusion, test};
+
+#[test]
+unconstrained fn note_inclusion() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(false);
+
+    let context = &mut env.private();
+
+    // docs:start:prove_note_inclusion
+    context.historical_header.prove_note_inclusion(retrieved_note, 15);
+    // docs:end:prove_note_inclusion
+}
+
+#[test(should_fail_with = "not found in NOTE_HASH_TREE at block 1")]
+unconstrained fn note_inclusion_fails() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(false);
+
+    let context = &mut env.private_at(1);
+    context.historical_header.prove_note_inclusion(retrieved_note, 15);
+}

noir-projects/aztec-nr/aztec/src/history/note_validity.nr

@@ -5,6 +5,8 @@ use crate::{
 
 use dep::protocol_types::block_header::BlockHeader;
 
+mod test;
+
 trait ProveNoteValidity {
     fn prove_note_validity<Note>(
         header: BlockHeader,

noir-projects/aztec-nr/aztec/src/history/note_validity/test.nr

@@ -0,0 +1,30 @@
+use crate::history::note_validity::ProveNoteValidity;
+use crate::history::test;
+
+#[test(should_fail_with = "not found in NOTE_HASH_TREE at block 1")]
+unconstrained fn note_not_valid_due_to_non_inclusion() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private_at(1);
+
+    context.historical_header.prove_note_validity(retrieved_note, 15, context);
+}
+
+#[test]
+unconstrained fn note_is_valid() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private_at(2);
+
+    // docs:start:prove_note_validity
+    context.historical_header.prove_note_validity(retrieved_note, 15, context);
+    // docs:end:prove_note_validity
+}
+
+#[test(should_fail_with = "Proving nullifier non-inclusion failed")]
+unconstrained fn note_not_valid_due_to_nullification() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private();
+    context.historical_header.prove_note_validity(retrieved_note, 15, context);
+}

noir-projects/aztec-nr/aztec/src/history/nullifier_inclusion.nr

@@ -11,6 +11,8 @@ use crate::{
     oracle::get_nullifier_membership_witness::get_nullifier_membership_witness,
 };
 
+mod test;
+
 trait ProveNullifierInclusion {
     fn prove_nullifier_inclusion(header: BlockHeader, nullifier: Field);
 }

noir-projects/aztec-nr/aztec/src/history/nullifier_inclusion/test.nr

@@ -0,0 +1,40 @@
+use crate::history::{nullifier_inclusion::{ProveNoteIsNullified, ProveNullifierInclusion}, test};
+use crate::oracle::random::random;
+
+#[test]
+unconstrained fn note_is_nullified() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private();
+
+    context.historical_header.prove_note_is_nullified(retrieved_note, 15, context);
+}
+
+#[test(should_fail_with = "Nullifier membership witness not found at block 2.")]
+unconstrained fn note_is_not_nullified() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private_at(2);
+
+    context.historical_header.prove_note_is_nullified(retrieved_note, 15, context);
+}
+
+#[test]
+unconstrained fn nullifier_inclusion() {
+    let (env) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private_at(2);
+
+    // We use the first nullifier created (because the TXe creates deterministic first nullifiers if no side-effects are emitted)
+    // docs:start:prove_nullifier_inclusion
+    context.historical_header.prove_nullifier_inclusion(6969 + 1);
+    // docs:end:prove_nullifier_inclusion
+}
+
+#[test(should_fail_with = "Nullifier membership witness not found")]
+unconstrained fn nullifier_inclusion_fails() {
+    let (env) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private();
+    context.historical_header.prove_nullifier_inclusion(random());
+}

noir-projects/aztec-nr/aztec/src/history/nullifier_non_inclusion.nr

@@ -13,6 +13,8 @@ use dep::protocol_types::{
 };
 use dep::protocol_types::merkle_tree::root::root_from_sibling_path;
 
+mod test;
+
 trait ProveNullifierNonInclusion {
     fn prove_nullifier_non_inclusion(header: BlockHeader, nullifier: Field);
 }

noir-projects/aztec-nr/aztec/src/history/nullifier_non_inclusion/test.nr

@@ -0,0 +1,40 @@
+use crate::history::nullifier_non_inclusion::{ProveNoteNotNullified, ProveNullifierNonInclusion};
+use crate::oracle::random::random;
+
+use crate::history::test;
+
+#[test]
+unconstrained fn note_not_nullified() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private_at(2);
+
+    context.historical_header.prove_note_not_nullified(retrieved_note, 15, context);
+}
+
+#[test(should_fail_with = "Proving nullifier non-inclusion failed")]
+unconstrained fn note_not_nullified_fails() {
+    let (env, retrieved_note) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private();
+    context.historical_header.prove_note_not_nullified(retrieved_note, 15, context);
+}
+
+#[test]
+unconstrained fn nullifier_non_inclusion() {
+    let (env) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private_at(2);
+
+    context.historical_header.prove_nullifier_non_inclusion(random());
+}
+
+#[test(should_fail_with = "Proving nullifier non-inclusion failed")]
+unconstrained fn nullifier_non_inclusion_fails() {
+    let (env) = test::create_note_and_optionally_nullify_it(true);
+
+    let context = &mut env.private();
+
+    // We use the first nullifier created (because the TXe creates deterministic first nullifiers if no side-effects are emitted)
+    context.historical_header.prove_nullifier_non_inclusion(6969 + 1);
+}

noir-projects/aztec-nr/aztec/src/history/public_storage.nr

@@ -6,6 +6,8 @@ use dep::protocol_types::merkle_tree::root::root_from_sibling_path;
 
 use crate::oracle::get_public_data_witness::get_public_data_witness;
 
+mod test;
+
 trait PublicStorageHistoricalRead {
     fn public_storage_historical_read(
         header: BlockHeader,

noir-projects/aztec-nr/aztec/src/history/public_storage/test.nr

@@ -0,0 +1,40 @@
+use crate::{
+    history::public_storage::PublicStorageHistoricalRead,
+    oracle::execution::get_contract_address,
+    test::{helpers::test_environment::TestEnvironment, mocks::mock_note::MockNote},
+};
+
+unconstrained fn setup() -> &mut TestEnvironment {
+    let mut env = TestEnvironment::new();
+    let context = &mut env.public();
+
+    context.storage_write(15, 69);
+
+    env.advance_block_by(1);
+
+    &mut env
+}
+
+#[test]
+unconstrained fn public_storage_read() {
+    let env = setup();
+
+    let context = &mut env.private();
+
+    assert_eq(
+        context.historical_header.public_storage_historical_read(15, get_contract_address()),
+        69,
+    );
+}
+
+#[test]
+unconstrained fn public_storage_read_empty() {
+    let env = setup();
+
+    let context = &mut env.private_at(1);
+
+    assert_eq(
+        context.historical_header.public_storage_historical_read(15, get_contract_address()),
+        0,
+    );
+}