feat!: improve testenv acct creation api (#16007)

I renamed `create_account` to `create_light_account` and
`create_account_contract` to `create_contract_account`. I think these
names better convey the difference between the two functions. I also
added documentation for what these functions do and how they differ.

Additionally, I removed the `secret` param from these functions, since
the caller never cared at all what the secret was, but was forced to
pass different ones in each call to avoid getting repeat accounts.
Instead I just keep track of it inside `TestEnvironment`. We
additionally now have separate tracking for light and contract accounts,
which means that all contract accounts now get generated with the same
secret sequence, resulting in better usage of our cache.

(e.g. before if a test did `light(0) contract(1)` and another did
`contract(0) light(1)` that'd be two cache misses, but now that results
in `light(0) contract(0)` for both tests, resulting in a cache hit. The
only thing that matters now is how many contract accounts you create in
total)

---------

Co-authored-by: benesjan <janbenes1234@gmail.com>

Author: nventuro

noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr

@@ -7,8 +7,6 @@ use crate::{
 };
 use dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};
 
-mod test;
-
 pub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {
     get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app
 }
@@ -34,3 +32,61 @@ pub fn get_public_keys(account: AztecAddress) -> PublicKeys {
 
     public_keys
 }
+
+mod test {
+    use super::get_public_keys;
+
+    use crate::test::helpers::test_environment::TestEnvironment;
+    use protocol_types::traits::Serialize;
+    use std::test::OracleMock;
+
+    global KEY_ORACLE_RESPONSE_LENGTH: u32 = 13; // 12 fields for the keys, one field for the partial address
+
+    #[test(should_fail_with = "Invalid public keys hint for address")]
+    unconstrained fn get_public_keys_fails_with_bad_hint() {
+        let mut env = TestEnvironment::new();
+        let account = env.create_light_account();
+
+        // Instead of querying for some unknown account, which would result in the oracle erroring out, we mock a bad oracle
+        // response to check that the circuit properly checks the address derivation.
+        let mut random_keys_and_partial_address = [0; KEY_ORACLE_RESPONSE_LENGTH];
+        // We use randomly generated points on the curve, and a random partial address to ensure that
+        // this combination does not derive the address and we should see the assertion fail.
+        // npk_m
+        random_keys_and_partial_address[0] =
+            0x292364b852c6c6f01472951e76a39cbcf074591fd0e063a81965e7b51ad868a5;
+        random_keys_and_partial_address[1] =
+            0x0a687b46cdc9238f1c311f126aaaa4acbd7a737bff2efd7aeabdb8d805843a27;
+        random_keys_and_partial_address[2] =
+            0x0000000000000000000000000000000000000000000000000000000000000000;
+        // ivpk_m
+        random_keys_and_partial_address[3] =
+            0x173c5229a00c5425255680dd6edc27e278c48883991f348fe6985de43b4ec25f;
+        random_keys_and_partial_address[4] =
+            0x1698608e23b5f6c2f43c49a559108bb64e2247b8fc2da842296a416817f40b7f;
+        random_keys_and_partial_address[5] =
+            0x0000000000000000000000000000000000000000000000000000000000000000;
+        // ovpk_m
+        random_keys_and_partial_address[6] =
+            0x1bad2f7d1ad960a1bd0fe4d2c8d17f5ab4a86ef8b103e0a9e7f67ec0d3b4795e;
+        random_keys_and_partial_address[7] =
+            0x206db87110abbecc9fbaef2c865189d94ef2c106202f734ee4eba9257fd28bf1;
+        random_keys_and_partial_address[8] =
+            0x0000000000000000000000000000000000000000000000000000000000000000;
+        // tpk_m
+        random_keys_and_partial_address[9] =
+            0x05e3bd9cfe6b47daa139613619cf7d7fd8bb0112b6f2908caa6d9b536ed948ed;
+        random_keys_and_partial_address[10] =
+            0x051066f877c9df47552d02e7dc32127ff4edefc8498e813bca1cbd3f5d1be429;
+        random_keys_and_partial_address[11] =
+            0x0000000000000000000000000000000000000000000000000000000000000000;
+        // partial address
+        random_keys_and_partial_address[12] =
+            0x236703e2cb00a182e024e98e9f759231b556d25ff19f98896cebb69e9e678cc9;
+
+        let _ = OracleMock::mock("getPublicKeysAndPartialAddress").returns(
+            random_keys_and_partial_address.serialize(),
+        );
+        let _ = get_public_keys(account);
+    }
+}

noir-projects/aztec-nr/aztec/src/keys/getters/test.nr

@@ -17,7 +17,31 @@ use super::txe_oracles::public_call_new_flow;
 
 mod test;
 
-pub struct TestEnvironment {}
+struct Counter {
+    next_value: Field,
+}
+
+impl Counter {
+    fn new() -> Self {
+        Self { next_value: 0 }
+    }
+
+    fn next(&mut self) -> Field {
+        let ret = self.next_value;
+        self.next_value += 1;
+        ret
+    }
+}
+
+pub struct TestEnvironment {
+    // The secrets to be used for light and contract account creation. By keeping track of the last used secret we can
+    // issue new ones automatically without requiring the user to provide different ones. Additionally, having the
+    // secrets be deterministic for each set of accounts and all concurrent tests results in TXE being able to maximize
+    // cache usage and not have to recompute account addresses and contract artifacts, which are relatively expensive
+    // operations.
+    light_account_secret: Counter,
+    contract_account_secret: Counter,
+}
 
 pub struct CallResult<T> {
     pub return_value: T,
@@ -47,12 +71,12 @@ impl PrivateContextOptions {
 
 impl TestEnvironment {
     pub unconstrained fn new() -> Self {
-        Self {}
+        Self { light_account_secret: Counter::new(), contract_account_secret: Counter::new() }
     }
 
     pub unconstrained fn _new() -> Self {
         txe_oracles::enable_context_checks();
-        Self {}
+        Self { light_account_secret: Counter::new(), contract_account_secret: Counter::new() }
     }
 
     /// EXPERIMENTAL FEATURE - NOT MEANT FOR EXTERNAL USE
@@ -262,13 +286,20 @@ impl TestEnvironment {
         txe_oracles::advance_timestamp_by(duration);
     }
 
-    pub unconstrained fn create_account(_self: Self, secret: Field) -> AztecAddress {
-        let test_account = txe_oracles::create_account(secret);
-        test_account.address
-    }
-
-    pub unconstrained fn create_account_contract(self, secret: Field) -> AztecAddress {
-        let test_account = txe_oracles::add_account(secret);
+    /// Creates a new account that can be used as the `from` parameter in contract calls, e.g. in `private_call` or
+    /// `public_call`, or be made the owner or recipient of notes in `private_context`.
+    ///
+    /// The returned account has a full set of privacy keys, so it can nullify notes, receive messages, etc. It also has
+    /// an associated `SchnorrAccount` contract that can process authwit requests - the authwits can be added via the
+    /// `add_private_authwit_from_call_interface` and `add_public_authwit_from_call_interface` helper functions. If
+    /// authwits are not required, consider using `create_light_account` instead, which is a faster variant of this
+    /// function.
+    ///
+    /// Each call to `create_contract_account` will return a different address, and so it can be called repeatedly to
+    /// generate multiple addresses. These addresses are also different from the ones that `create_light_account`
+    /// returns, and so these two functions can be mixed and match to create a set of unique accounts.
+    pub unconstrained fn create_contract_account(&mut self) -> AztecAddress {
+        let test_account = txe_oracles::add_account(self.contract_account_secret.next());
         let address = test_account.address;
 
         let _ = self.call_private(
@@ -285,6 +316,21 @@ impl TestEnvironment {
         address
     }
 
+    /// Creates a new account that can be used as the `from` parameter in contract calls, e.g. in `private_call` or
+    /// `public_call`, or be made the owner or recipient of notes in `private_context`. This is a faster variant of
+    /// `create_contract_account`, but comes with reduced capabilities.
+    ///
+    /// The returned account has a full set of privacy keys, so it can nullify notes, receive messages, etc. It doesn't
+    /// however have an associated account contract, so it cannot process private authwit requests.
+    ///
+    /// Each call to `create_light_account` will return a different address, and so it can be called repeatedly to
+    /// generate multiple addresses. These addresses are also different from the ones that `create_contract_account`
+    /// returns, and so these two functions can be mixed and match to create a set of unique accounts.
+    pub unconstrained fn create_light_account(&mut self) -> AztecAddress {
+        let test_account = txe_oracles::create_account(self.light_account_secret.next());
+        test_account.address
+    }
+
     pub unconstrained fn deploy<let N: u32, let M: u32>(
         self: Self,
         path: str<N>,

noir-projects/aztec-nr/aztec/src/test/helpers/test_environment.nr

@@ -1,5 +1,6 @@
 use crate::test::helpers::test_environment::TestEnvironment;
 
+mod accounts;
 mod private_context;
 mod public_context;
 

noir-projects/aztec-nr/aztec/src/test/helpers/test_environment/test.nr

@@ -0,0 +1,130 @@
+use crate::{
+    authwit::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR},
+    context::call_interfaces::PrivateCallInterface,
+    keys::getters::get_public_keys,
+    test::helpers::{test_environment::TestEnvironment, txe_oracles},
+};
+use protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};
+
+#[test]
+unconstrained fn create_light_account_does_not_repeat_accounts() {
+    let mut env = TestEnvironment::_new();
+
+    let first_account = env.create_light_account();
+    let second_account = env.create_light_account();
+
+    assert(first_account != second_account);
+}
+
+#[test]
+unconstrained fn create_contract_account_does_not_repeat_accounts() {
+    let mut env = TestEnvironment::new();
+
+    let first_account = env.create_contract_account();
+    let second_account = env.create_contract_account();
+
+    assert(first_account != second_account);
+}
+
+#[test]
+unconstrained fn light_and_contract_accounts_do_not_share_addresses() {
+    let mut env = TestEnvironment::new();
+
+    let light_account = env.create_light_account();
+    let contract_account = env.create_contract_account();
+
+    assert(light_account != contract_account);
+}
+
+#[test]
+unconstrained fn light_accounts_have_valid_keys() {
+    let mut env = TestEnvironment::new();
+    let light_account = env.create_light_account();
+
+    let _ = get_public_keys(light_account);
+}
+
+#[test]
+unconstrained fn contract_accounts_have_valid_keys() {
+    let mut env = TestEnvironment::new();
+    let contract_account = env.create_contract_account();
+
+    let _ = get_public_keys(contract_account);
+}
+
+#[test(should_fail_with = "use `create_contract_account` instead of `create_light_account` for authwit support")]
+unconstrained fn light_accounts_fail_on_private_authwit_checks() {
+    let mut env = TestEnvironment::new();
+    let light_account = env.create_light_account();
+
+    let inner_hash = 13;
+    let caller = AztecAddress::zero();
+
+    let _: Field = env
+        .call_private(
+            caller,
+            PrivateCallInterface::new(
+                light_account,
+                comptime { FunctionSelector::from_signature("verify_private_authwit(Field)") },
+                "verify_private_authwit",
+                [inner_hash],
+                true,
+            ),
+        )
+        .return_value;
+}
+
+#[test(should_fail_with = "Unknown auth witness")]
+unconstrained fn contract_accounts_reject_invalid_private_authwits() {
+    let mut env = TestEnvironment::new();
+    let contract_account = env.create_contract_account();
+
+    let inner_hash = 13;
+    let caller = AztecAddress::zero();
+
+    let _: Field = env
+        .call_private(
+            caller,
+            PrivateCallInterface::new(
+                contract_account,
+                comptime { FunctionSelector::from_signature("verify_private_authwit(Field)") },
+                "verify_private_authwit",
+                [inner_hash],
+                true,
+            ),
+        )
+        .return_value;
+}
+
+#[test]
+unconstrained fn contract_accounts_accept_valid_private_authwits() {
+    let mut env = TestEnvironment::new();
+    let contract_account = env.create_contract_account();
+
+    let inner_hash = 13;
+    let caller = AztecAddress::zero();
+
+    env.private_context(|context| {
+        let message_hash = compute_authwit_message_hash(
+            caller,
+            context.chain_id(),
+            context.version(),
+            inner_hash,
+        );
+        txe_oracles::add_authwit(contract_account, message_hash);
+    });
+
+    let result = env
+        .call_private(
+            caller,
+            PrivateCallInterface::new(
+                contract_account,
+                comptime { FunctionSelector::from_signature("verify_private_authwit(Field)") },
+                "verify_private_authwit",
+                [inner_hash],
+                true,
+            ),
+        )
+        .return_value;
+    assert_eq(result, IS_VALID_SELECTOR);
+}

noir-projects/aztec-nr/aztec/src/test/helpers/test_environment/test/accounts.nr

@@ -5,11 +5,11 @@ use aztec::{
 };
 
 unconstrained fn setup() -> (TestEnvironment, AztecAddress, AztecAddress, AztecAddress, AztecAddress) {
-    let env = TestEnvironment::new();
+    let mut env = TestEnvironment::new();
 
-    let admin = env.create_account(1);
-    let to_authorize = env.create_account(2);
-    let other = env.create_account(3);
+    let admin = env.create_light_account();
+    let to_authorize = env.create_light_account();
+    let other = env.create_light_account();
 
     let initializer_call_interface = Auth::interface().constructor(admin);