feat: aztec nr lib constraining nullifier key is fresh

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

@@ -0,0 +1,3 @@
+mod assert_public_key_freshness;
+
+use crate::keys::assert_public_key_freshness::assert_nullifier_public_key_is_fresh;

noir-projects/aztec-nr/aztec/src/keys/assert_public_key_freshness.nr

@@ -0,0 +1,67 @@
+use dep::protocol_types::{
+  address::{
+    AztecAddress,
+    PartialAddress
+  }, 
+  constants::{
+    GENERATOR_INDEX__PUBLIC_KEYS_HASH,
+    GENERATOR_INDEX__CONTRACT_ADDRESS_V1,
+    CANONICAL_KEY_REGISTRY_ADDRESS
+  },
+  grumpkin_point::GrumpkinPoint,
+};
+
+use crate::context::PrivateContext;
+use crate::hash::{
+  pedersen_hash, 
+  poseidon2_hash,
+};
+use crate::oracle;
+use crate::state_vars::shared_mutable::shared_mutable_private_getter::SharedMutablePrivateGetter;
+
+struct PublicKeyTypeEnum {
+  NULLIFIER: u8,
+}
+
+global PublicKeyType = PublicKeyTypeEnum {
+  NULLIFIER: 0,
+};
+
+pub fn assert_nullifier_public_key_is_fresh(
+  context: &mut PrivateContext,
+  address: AztecAddress, 
+  nullifier_public_key_to_test: GrumpkinPoint,
+) {
+  // This is the storage slot of the nullifier_public_key inside the key registry contract
+  let storage_slot_of_nullifier_public_key = 1;
+  // We have to derive this slot to get the location of the shared mutable inside the Map
+  // This should mimic how maps derive their slots
+  let derived_slot = pedersen_hash(
+    [storage_slot_of_nullifier_public_key, address.to_field()],
+    0
+  );
+
+  // It's a bit wonky because we need to know the delay for get_current_value_in_private to work correctly
+  // We read from the canonical Key Registry
+  let registry_private_getter: SharedMutablePrivateGetter<Field, 5> = SharedMutablePrivateGetter::new(*context, AztecAddress::from_field(CANONICAL_KEY_REGISTRY_ADDRESS), derived_slot);
+  let hashed_nullifier_public_key_in_registry = registry_private_getter.get_current_value_in_private();
+
+  // In the case that the value is not found in the registry we need to manually pass in the address preimage
+  if (hashed_nullifier_public_key_in_registry == 0) {
+    check_public_key_validity(address, PublicKeyType.NULLIFIER, nullifier_public_key_to_test);
+  } else {
+    assert(hashed_nullifier_public_key_in_registry == poseidon2_hash(nullifier_public_key_to_test.serialize()));
+  }
+}
+
+fn check_public_key_validity(address: AztecAddress, key_type: u8, key: GrumpkinPoint) {
+  let keys = get_public_keys_internal(address);
+
+  assert(keys[key_type].eq(key));
+}
+
+fn get_public_keys_internal(address: AztecAddress) -> [GrumpkinPoint; 4] {
+  let (_, public_keys) = oracle::keys::get_public_keys_and_partial_address(address);
+
+  public_keys
+}

noir-projects/aztec-nr/aztec/src/lib.nr

@@ -3,6 +3,7 @@ mod deploy;
 mod hash;
 mod history;
 mod initializer;
+mod keys;
 mod log;
 mod messaging;
 mod note;

noir-projects/aztec-nr/aztec/src/oracle.nr

@@ -11,6 +11,7 @@ mod get_nullifier_membership_witness;
 mod get_public_data_witness;
 mod get_membership_witness;
 mod get_public_key;
+mod keys;
 mod nullifier_key;
 mod get_sibling_path;
 mod unsafe_rand;

noir-projects/aztec-nr/aztec/src/oracle/keys.nr

@@ -0,0 +1,76 @@
+use dep::protocol_types::{
+  address::{
+    AztecAddress,
+    PartialAddress,
+    PublicKeysHash,
+  }, 
+  constants::{
+    GENERATOR_INDEX__PUBLIC_KEYS_HASH,
+    GENERATOR_INDEX__CONTRACT_ADDRESS_V1,
+  },
+  grumpkin_point::GrumpkinPoint,
+};
+
+use crate::hash::poseidon2_hash;
+
+#[oracle(getPublicKeysAndPartialAddress)]
+fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 9] {}
+
+unconstrained fn get_public_keys_and_partial_address_oracle_wrapper(address: AztecAddress) -> [Field; 9] {
+  get_public_keys_and_partial_address_oracle(address)
+}
+
+pub fn get_public_keys_and_partial_address(address: AztecAddress) -> (PartialAddress, [GrumpkinPoint; 4]) {
+  let result = get_public_keys_and_partial_address_oracle_wrapper(address);
+
+  let partial_address = PartialAddress::from_field(result[0]);
+  let nullifier_pub_key = GrumpkinPoint::new(result[1], result[2]);
+  let incoming_pub_key = GrumpkinPoint::new(result[3], result[4]);
+  let outgoing_pub_key = GrumpkinPoint::new(result[5], result[6]);
+  let tagging_pub_key = GrumpkinPoint::new(result[7], result[8]);
+
+  _check_public_key_validity_constrain_oracle(
+    address,
+    partial_address,
+    nullifier_pub_key,
+    incoming_pub_key,
+    outgoing_pub_key,
+    tagging_pub_key,
+  );
+
+  (partial_address, [nullifier_pub_key, incoming_pub_key, outgoing_pub_key, tagging_pub_key])
+}
+
+fn _check_public_key_validity_constrain_oracle(
+  address: AztecAddress,
+  partial_address: PartialAddress,
+  nullifier_public_key: GrumpkinPoint,
+  incoming_public_key: GrumpkinPoint,
+  outgoing_public_key: GrumpkinPoint,
+  tagging_public_key: GrumpkinPoint
+  ) {
+  let public_keys_hash = poseidon2_hash([
+      nullifier_public_key.serialize()[0],
+      nullifier_public_key.serialize()[1],
+      incoming_public_key.serialize()[0],
+      incoming_public_key.serialize()[1],
+      outgoing_public_key.serialize()[0],
+      outgoing_public_key.serialize()[1],
+      tagging_public_key.serialize()[0],
+      tagging_public_key.serialize()[1],
+      GENERATOR_INDEX__PUBLIC_KEYS_HASH,
+  ]);
+
+// TODO: #5830: we can compute this like below once refactored
+// let calculated_address = AztecAddress::compute(PublicKeysHash::compute(pub_key), partial_address);
+
+  let computed_address = AztecAddress::from_field(
+    poseidon2_hash([
+      partial_address.to_field(),
+      public_keys_hash.to_field(),
+      GENERATOR_INDEX__CONTRACT_ADDRESS_V1,
+    ])
+  );
+
+  assert(computed_address.eq(address));
+}

noir-projects/noir-contracts/contracts/key_registry_contract/src/main.nr

@@ -7,6 +7,7 @@ contract KeyRegistry {
       Map
     }, 
     protocol_types::{
+      grumpkin_point::GrumpkinPoint,
       address::{
         AztecAddress,
         PublicKeysHash,
@@ -26,7 +27,7 @@ contract KeyRegistry {
   struct Storage {
     // We are not supporting rotating / changing keys other than the nullifier public in the registry at the moment, but will in the future.
     // Uncomment lines below to enable that functionality
-    nullifier_public_key_registry: Map<AztecAddress, SharedMutable<Field, KEY_ROTATION_DELAY>>,
+    nullifier_public_key_hash_registry: Map<AztecAddress, SharedMutable<Field, KEY_ROTATION_DELAY>>,
     // incoming_public_key_registry: Map<AztecAddress, SharedMutable<Field, KEY_ROTATION_DELAY>>,
     // outgoing_public_key_registry: Map<AztecAddress, SharedMutable<Field, KEY_ROTATION_DELAY>>,
     // tagging_public_key_registry: Map<AztecAddress, SharedMutable<Field, KEY_ROTATION_DELAY>>,
@@ -35,36 +36,37 @@ contract KeyRegistry {
   #[aztec(public)]
   fn rotate_nullifier_public_key(
     address: AztecAddress,
-    new_nullifier_public_key: Field,
+    new_nullifier_public_key: GrumpkinPoint,
   ) {
     assert(
-      new_nullifier_public_key != 0,
+      !new_nullifier_public_key.is_zero(),
       "New nullifier public key must be non-zero"
     );
 
     if (!address.eq(context.msg_sender())) {
       assert_current_call_valid_authwit_public(&mut context, address);
     }
 
-    let nullifier_key_registry = storage.nullifier_public_key_registry.at(address);
+    let nullifier_key_registry = storage.nullifier_public_key_hash_registry.at(address);
 
-    nullifier_key_registry.schedule_value_change(new_nullifier_public_key);
+    nullifier_key_registry.schedule_value_change(poseidon2_hash(new_nullifier_public_key.serialize()));
   }
 
   #[aztec(public)]
   fn register(
     address: AztecAddress,
     partial_address: PartialAddress,
-    nullifier_public_key: Field,
-    incoming_public_key: Field,
-    outgoing_public_key: Field,
-    tagging_public_key: Field,
+    nullifier_public_key: GrumpkinPoint,
+    incoming_public_key: GrumpkinPoint,
+    outgoing_public_key: GrumpkinPoint,
+    tagging_public_key: GrumpkinPoint,
   ) {
     assert(
-      (nullifier_public_key != 0) &
-      (incoming_public_key != 0) &
-      (outgoing_public_key != 0) &
-      (tagging_public_key != 0),
+      !partial_address.is_zero() &
+      !nullifier_public_key.is_zero() &
+      !incoming_public_key.is_zero() &
+      !outgoing_public_key.is_zero() &
+      !tagging_public_key.is_zero(),
        "All public keys must be non-zero"
     );
 
@@ -73,10 +75,14 @@ contract KeyRegistry {
     // let address = AztecAddress::compute(public_keys_hash, partial_address);
     // We could also pass in original_public_keys_hash instead of computing it here, if all we need the original one is for being able to prove ownership of address
     let public_keys_hash = poseidon2_hash([
-        nullifier_public_key,
-        incoming_public_key,
-        outgoing_public_key,
-        tagging_public_key,
+        nullifier_public_key.serialize()[0],
+        nullifier_public_key.serialize()[1],
+        incoming_public_key.serialize()[0],
+        incoming_public_key.serialize()[1],
+        outgoing_public_key.serialize()[0],
+        outgoing_public_key.serialize()[1],
+        tagging_public_key.serialize()[0],
+        tagging_public_key.serialize()[1],
         GENERATOR_INDEX__PUBLIC_KEYS_HASH,
       ]
     );
@@ -92,14 +98,14 @@ contract KeyRegistry {
 
     assert(computed_address.eq(address), "Computed address does not match supplied address");
 
-    let nullifier_key_registry = storage.nullifier_public_key_registry.at(address);
+    let nullifier_key_hash_registry = storage.nullifier_public_key_hash_registry.at(address);
     // We are not supporting rotating / changing keys other than the nullifier public in the registry at the moment, but will in the future.
     // Uncomment lines below to enable that functionality
     // let incoming_key_registry = storage.incoming_public_key_registry.at(address);
     // let outgoing_key_registry = storage.outgoing_public_key_registry.at(address);
     // let tagging_key_registry = storage.taggin_public_key_registry.at(address);
 
-    nullifier_key_registry.schedule_value_change(nullifier_public_key);
+    nullifier_key_hash_registry.schedule_value_change(poseidon2_hash(nullifier_public_key.serialize()));
     // We are not supporting rotating / changing keys other than the nullifier public in the registry at the moment, but will in the future.
     // Uncomment lines below to enable that functionality    // incoming_key_registry.schedule_value_change(new_incoming_public_key);
     // outgoing_key_registry.schedule_value_change(new_outgoing_public_key);

noir-projects/noir-contracts/contracts/test_contract/src/main.nr

@@ -10,14 +10,16 @@ contract Test {
 
     use dep::aztec::protocol_types::{
         abis::private_circuit_public_inputs::PrivateCircuitPublicInputs,
-        constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, traits::Serialize
+        constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, traits::Serialize,
+        grumpkin_point::GrumpkinPoint
     };
 
     use dep::aztec::note::constants::MAX_NOTES_PER_PAGE;
 
     use dep::aztec::state_vars::shared_mutable::SharedMutablePrivateGetter;
 
     use dep::aztec::{
+        keys::assert_public_key_freshness::assert_nullifier_public_key_is_fresh,
         context::{Context, inputs::private_context_inputs::PrivateContextInputs},
         hash::{pedersen_hash, compute_secret_hash, ArgsHasher},
         note::{
@@ -387,7 +389,7 @@ contract Test {
             0
         );
         // It's a bit wonky because we need to know the delay for get_current_value_in_private to work correctly
-        let registry_private_getter: SharedMutablePrivateGetter<AztecAddress, 5> = SharedMutablePrivateGetter::new(context, contract_address_to_read, derived_slot);
+        let registry_private_getter: SharedMutablePrivateGetter<Field, 5> = SharedMutablePrivateGetter::new(context, contract_address_to_read, derived_slot);
         let nullifier_public_key = registry_private_getter.get_current_value_in_private();
 
         context.emit_unencrypted_log(nullifier_public_key);
@@ -409,6 +411,14 @@ contract Test {
         context.emit_unencrypted_log(authorized);
     }
 
+    #[aztec(private)]
+    fn test_nullifier_key_freshness(
+        address: AztecAddress,
+        public_nullifying_key: GrumpkinPoint,
+    ) {
+        assert_nullifier_public_key_is_fresh(&mut context, address, public_nullifying_key);
+    }
+
     #[aztec(public)]
     fn delay() {
         // We use this as a util function to "mine a block"

noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr

@@ -68,6 +68,10 @@ impl PartialAddress {
         self.inner
     }
 
+    pub fn is_zero(self) -> bool {
+        self.to_field() == 0
+    }
+
     pub fn assert_is_zero(self) {
         assert(self.to_field() == 0);
     }

yarn-project/circuit-types/src/interfaces/pxe.ts

@@ -1,4 +1,4 @@
-import { type AztecAddress, type CompleteAddress, type Fr, type PartialAddress } from '@aztec/circuits.js';
+import { type AztecAddress, type CompleteAddress, type Fr, type PartialAddress, type Point } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type ContractClassWithId, type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type NodeInfo } from '@aztec/types/interfaces';
@@ -73,7 +73,8 @@ export interface PXE {
    * the recipient's notes. We can send notes to this account because we can encrypt them with the recipient's
    * public key.
    */
-  registerRecipient(recipient: CompleteAddress): Promise<void>;
+  // TODO: #5834: FIX THIS AFTER THE COMPLETE ADDRESS REFACTOR
+  registerRecipient(recipient: CompleteAddress, publicKeys?: Point[]): Promise<void>;
 
   /**
    * Retrieves the user accounts registered on this PXE Service.

yarn-project/circuit-types/src/keys/key_store.ts

@@ -3,6 +3,7 @@ import {
   type Fr,
   type GrumpkinPrivateKey,
   type PartialAddress,
+  type Point,
   type PublicKey,
 } from '@aztec/circuits.js';
 
@@ -116,4 +117,20 @@ export interface KeyStore {
    * @returns A Promise that resolves to the public keys hash.
    */
   getPublicKeysHash(account: AztecAddress): Promise<Fr>;
+
+  /**
+   * This is used to register a recipient / for storing public keys of an address
+   * @param accountAddress - The account address to store keys for.
+   * @param masterNullifierPublicKey - The stored master nullifier public key
+   * @param masterIncomingViewingPublicKey - The stored incoming viewing public key
+   * @param masterOutgoingViewingPublicKey - The stored outgoing viewing public key
+   * @param masterTaggingPublicKey - The stored master tagging public key
+   */
+  addPublicKeysForAccount(
+    accountAddress: AztecAddress,
+    masterNullifierPublicKey: Point,
+    masterIncomingViewingPublicKey: Point,
+    masterOutgoingViewingPublicKey: Point,
+    masterTaggingPublicKey: Point,
+  ): Promise<void>;
 }

yarn-project/end-to-end/jest.integration.config.json

@@ -6,7 +6,7 @@
   "moduleNameMapper": {
     "^(\\.{1,2}/.*)\\.js$": "$1"
   },
-  "reporters": [["default", {"summaryThreshold": 9999}]],
+  "reporters": [["default", { "summaryThreshold": 9999 }]],
   "testRegex": "./src/.*\\.test\\.ts$",
   "rootDir": "./src"
 }