feat: inclusion and non-inclusion proofs experiment

yarn-project/aztec-nr/aztec/src/context.nr

@@ -46,6 +46,7 @@ use crate::oracle::{
     public_call::call_public_function_internal,
     enqueue_public_function_call::enqueue_public_function_call_internal,
     context::get_portal_address,
+    get_block_data::get_block_data,
 };
 
 use dep::std::option::Option;
@@ -128,6 +129,10 @@ impl PrivateContext {
         self.inputs.call_context.function_selector
     }
 
+    pub fn get_block_data(self, block_number: Field) -> HistoricBlockData {
+        get_block_data(block_number, self)
+    }
+
     pub fn finish(self) -> abi::PrivateCircuitPublicInputs {
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)
         let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];

yarn-project/end-to-end/src/e2e_inclusion_proofs_contract.test.ts

@@ -1,4 +1,4 @@
-import { AccountWallet, CompleteAddress, PXE } from '@aztec/aztec.js';
+import { AccountWallet, AztecAddress, CompleteAddress, Fr, PXE } from '@aztec/aztec.js';
 import { InclusionProofsContract } from '@aztec/noir-contracts/types';
 
 import { jest } from '@jest/globals';
@@ -29,7 +29,7 @@ describe('e2e_inclusion_proofs_contract', () => {
 
   afterAll(() => teardown());
 
-  it('creates a note and proves its existence', async () => {
+  it('proves note existence and its nullifier non-existence and nullifier non-existence failure case', async () => {
     // Owner of a note
     const owner = accounts[0].address;
     {
@@ -48,14 +48,16 @@ describe('e2e_inclusion_proofs_contract', () => {
       // Prove note inclusion in a given block.
       // We prove the note existence at current block number because we don't currently have historical data
       const blockNumber = await pxe.getBlockNumber();
-      await contract.methods.proveNoteInclusion(owner, blockNumber).send().wait();
+      const ignoredCommitment = 0; // Not ignored only when the note doesn't exist
+      await contract.methods.proveNoteInclusion(owner, blockNumber, ignoredCommitment).send().wait();
     }
 
     {
       // Prove that the note has not been nullified
       // We prove the note existence at current block number because we don't currently have historical data
       const blockNumber = await pxe.getBlockNumber();
-      await contract.methods.proveNullifierNonInclusion(owner, blockNumber, 0).send().wait();
+      const ignoredNullifier = 0; // Not ignored only when the note doesn't exist
+      await contract.methods.proveNullifierNonInclusion(owner, blockNumber, ignoredNullifier).send().wait();
     }
 
     {
@@ -75,16 +77,44 @@ describe('e2e_inclusion_proofs_contract', () => {
     }
   });
 
+  it('note existence failure case', async () => {
+    // Owner of a note
+    const owner = AztecAddress.random();
+
+    const blockNumber = await pxe.getBlockNumber();
+    const randomNoteCommitment = Fr.random();
+    await expect(
+      contract.methods.proveNoteInclusion(owner, blockNumber, randomNoteCommitment).send().wait(),
+    ).rejects.toThrow(/Leaf value: 0x[0-9a-fA-F]+ not found in tree/);
+  });
+
   it('proves an existence of a public value in private context', async () => {
     const blockNumber = await pxe.getBlockNumber();
     await contract.methods.provePublicValueInclusion(publicValue, blockNumber).send().wait();
   });
 
+  it('public value existence failure case', async () => {
+    const blockNumber = await pxe.getBlockNumber();
+    const randomPublicValue = Fr.random();
+    await expect(
+      contract.methods.provePublicValueInclusion(randomPublicValue, blockNumber).send().wait(),
+    ).rejects.toThrow(/Proving membership of a value in public data tree failed/);
+  });
+
   it('proves existence of a nullifier in private context', async () => {
     const blockNumber = await pxe.getBlockNumber();
     const block = await pxe.getBlock(blockNumber);
     const nullifier = block?.newNullifiers[0];
 
     await contract.methods.proveNullifierInclusion(nullifier!, blockNumber).send().wait();
   });
+
+  it('nullifier existence failure case', async () => {
+    const blockNumber = await pxe.getBlockNumber();
+    const randomNullifier = Fr.random();
+
+    await expect(contract.methods.proveNullifierInclusion(randomNullifier, blockNumber).send().wait()).rejects.toThrow(
+      /Low nullifier witness not found for nullifier 0x[0-9a-fA-F]+ at block/,
+    );
+  });
 });

yarn-project/noir-contracts/src/contracts/inclusion_proofs_contract/src/main.nr

@@ -101,23 +101,29 @@ contract InclusionProofs {
     fn proveNoteInclusion(
         owner: AztecAddress,
         block_number: Field, // The block at which we'll prove that the note exists
+        spare_commitment: Field, // This is only used when the note is not found --> used to test the failure case
     ) {
         // TODO: assert that block number is less than the block number of context.block_data
         // --> This will either require a new oracle method that returns block_data.global_variables_hash preimage
         //     or modifying the private context so that we somehow expose it.
 
         // 1) Get historic block data from oracle and ensure that the block hash is included in the current blocks tree
         //    root.
-        let block_data = get_block_data(block_number, context);
+        let block_data = context.get_block_data(block_number);
 
         // 2) Get the note from PXE.
         let private_values = storage.private_values.at(owner.address);
         let options = NoteGetterOptions::new().select(1, owner.address).set_limit(1);
         let notes = private_values.get_notes(options);
-        let note = notes[0].unwrap();
+        let maybe_note = notes[0];
 
         // 3) Compute the commitment from the note
-        let note_commitment = note_utils::compute_unique_siloed_note_hash(ValueNoteMethods, note);
+        let note_commitment = if maybe_note.is_some() {
+            note_utils::compute_unique_siloed_note_hash(ValueNoteMethods, maybe_note.unwrap_unchecked())
+        } else {
+            // Note was not found so we will use the spare commitment
+            spare_commitment
+        };
 
         // 4) Get the membership witness of the note in the note hash tree
         let note_hash_tree_id = 2; // TODO(#3443)
@@ -146,7 +152,7 @@ contract InclusionProofs {
 
         // 1) Get historic block data from oracle and ensure that the block hash is included in the current blocks tree
         //    root.
-        let block_data = get_block_data(block_number, context);
+        let block_data = context.get_block_data(block_number);
 
         // 2) Get the note from PXE
         let private_values = storage.private_values.at(owner.address);
@@ -217,7 +223,7 @@ contract InclusionProofs {
 
         // 1) Get historic block data from oracle and ensure that the block hash is included in the current blocks tree
         //    root.
-        let block_data = get_block_data(block_number, context);
+        let block_data = context.get_block_data(block_number);
 
         // 2) Get the membership witness of the nullifier
         let witness = get_nullifier_membership_witness(block_number, nullifier);
@@ -249,7 +255,7 @@ contract InclusionProofs {
 
         // 1) Get historic block data from oracle and ensure that the block hash is included in the current blocks tree
         //    root.
-        let block_data = get_block_data(block_number, context);
+        let block_data = context.get_block_data(block_number);
 
         // 2) Compute the public value leaf index.
         // We have to compute the leaf index here because unlike in the case of note commitments, public values are