feat: store discovered handshakes as facts

Author: vezenovm

noir-projects/aztec-nr/aztec/src/messages/processing/log_retrieval_response.nr

@@ -19,4 +19,8 @@ pub struct LogRetrievalResponse {
     pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,
     /// The first nullifier created by `tx_hash`
     pub first_nullifier_in_tx: Field,
+    /// The block in which `tx_hash` was included
+    pub block_number: u32,
+    /// The timestamp of the block in which `tx_hash` was included
+    pub block_timestamp: u64,
 }

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

@@ -54,9 +54,7 @@ pub unconstrained fn get_logs_by_tag(
     get_logs_by_tag_oracle(requests)
 }
 
-// TODO: PXE also exposes `getLogsByTagV2`, whose response additionally carries the origin block number and timestamp
-// of each log. Switch this oracle (and `LogRetrievalResponse`) over to it once a consumer needs that context.
-#[oracle(aztec_utl_getLogsByTag)]
+#[oracle(aztec_utl_getLogsByTagV2)]
 unconstrained fn get_logs_by_tag_oracle(
     requests: EphemeralArray<LogRetrievalRequest>,
 ) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {}

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

@@ -2,17 +2,17 @@
 use protocol_types::{address::AztecAddress, traits::FromField};
 
 pub global STANDARD_AUTH_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x186fbbe15f50d01d67c471d5ed8b8be43b8826e77147cb0084302804e336e5d2,
+    0x2e5ddde017507a7faa104e9a26584bfcfb91873412ac912e127fc0280e96d44f,
 );
 
 pub global STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x10a91e72a359e7441d4af9e418f14862abe994348970909d484ff2dad1594a58,
+    0x19cd5344d6da9545c5bed85045f33c3db45abd5bbb2ca54b110bd29f53503d70,
 );
 
 pub global STANDARD_PUBLIC_CHECKS_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x1f6f565db58df81c2bbb8e9932fa92d2d1f537887a06e2cb965184f77a5235d2,
+    0x2af70394e3fe40203bc3271bc8e1ad9d6e8c9ffb547a354aaab7f1aca63c8697,
 );
 
 pub global STANDARD_HANDSHAKE_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x18233660a8797d74f63318c4223332e23b63f570da11fb142993ebc802a96728,
+    0x171fcd1d024cc5b3273945e50d7e6eb715dab71f2e13cb6dfc49a3ca6fc8642f,
 );

noir-projects/noir-contracts/contracts/standard/handshake_registry_contract/src/sync.nr

@@ -1,7 +1,10 @@
 use aztec::{
-    capsules::CapsuleArray,
     context::UtilityContext,
     ephemeral::EphemeralArray,
+    facts::{
+        delete_fact_collection, Fact, FactCollection, get_fact_collection, get_fact_collections_by_type, OriginBlock,
+        record_retractable_fact,
+    },
     messages::{
         delivery::handshake::DiscoveredHandshake,
         discovery::{
@@ -14,22 +17,34 @@ use aztec::{
             offchain::OffchainInboxSync,
         },
     },
-    oracle::{capsules, message_processing},
+    oracle::message_processing,
     protocol::{
         address::AztecAddress,
         constants::DOM_SEP__NON_INTERACTIVE_HANDSHAKE_LOG_TAG,
-        hash::{compute_log_tag, sha256_to_field},
-        traits::ToField,
+        hash::{compute_log_tag, poseidon2_hash, sha256_to_field},
+        traits::{Deserialize, Serialize, ToField},
     },
     utils::point::point_from_x_coord_and_sign,
 };
 
-/// Capsule base slot for the per-recipient list of discovered handshakes populated by
-/// [`handshake_registry_sync`] and read by [`get_all_handshakes`].
-global HANDSHAKES_CAPSULE_SLOT: Field = sha256_to_field("HANDSHAKE_REGISTRY::HANDSHAKES".as_bytes());
+/// Fact-collection type id of the per-recipient discovered handshakes populated by [`handshake_registry_sync`] and
+/// read by [`get_all_handshakes`]. Each discovered handshake lives in its own collection (see
+/// [`handshake_collection_id`]).
+pub(crate) global DISCOVERED_HANDSHAKES_TYPE_ID: Field =
+    sha256_to_field("HANDSHAKE_REGISTRY::DISCOVERED_HANDSHAKES".as_bytes());
+
+/// Fact type id of the fact storing a serialized [`DiscoveredHandshake`] inside a discovered-handshake collection.
+pub(crate) global HANDSHAKE_DISCOVERED: Field = sha256_to_field("HANDSHAKE_REGISTRY::HANDSHAKE_DISCOVERED".as_bytes());
+
+/// Fact-collection type id of the per-recipient sync cursor.
+pub(crate) global SYNC_CURSOR_TYPE_ID: Field = sha256_to_field("HANDSHAKE_REGISTRY::SYNC_CURSOR".as_bytes());
 
-/// Capsule slot for the per-recipient sync cursor: the next block (inclusive) the discovery scan should start from.
-global SYNC_CURSOR_CAPSULE_SLOT: Field = sha256_to_field("HANDSHAKE_REGISTRY::SYNC_CURSOR".as_bytes());
+/// Fact type id of the single fact in the cursor collection. The fact has an empty payload: the cursor value is its
+/// origin block (the anchor block of the last completed scan).
+pub(crate) global SYNC_CURSOR: Field = sha256_to_field("HANDSHAKE_REGISTRY::SYNC_CURSOR_FACT".as_bytes());
+
+/// Collection id of the singleton cursor collection.
+pub(crate) global SYNC_CURSOR_COLLECTION_ID: Field = 0;
 
 /// Ephemeral-array slot used by [`get_handshake_logs_in_range`] to batch a single log-retrieval request to the oracle.
 global LOG_RETRIEVAL_REQUEST_ARRAY_SLOT: Field =
@@ -38,11 +53,11 @@ global LOG_RETRIEVAL_REQUEST_ARRAY_SLOT: Field =
 /// Discovers non-interactive handshakes addressed to the syncing account.
 ///
 /// On every sync, scans the recipient-keyed bootstrap tag over the blocks mined since the previous sync, decrypts
-/// each matching log to recover the handshake `eph_pk`, and appends it to the recipient's
-/// capsule list. It then falls through to [`do_sync_state`] so that normal note/event/partial-note discovery still
-/// happens.
+/// each matching log to recover the handshake `eph_pk`, and records it as a retractable fact whose origin is the block
+/// the log landed in, so a reorg pruning that block makes the handshake invisible again. It then falls through to
+/// [`do_sync_state`] so that normal note/event/partial-note discovery still happens.
 ///
-/// `scope` is the account PXE is syncing for, which doubles as both the recipient whose tag we scan and the capsule
+/// `scope` is the account PXE is syncing for, which doubles as both the recipient whose tag we scan and the fact
 /// scope we persist under, so handshakes for one account never leak into another's list.
 pub(crate) unconstrained fn handshake_registry_sync(
     contract_address: AztecAddress,
@@ -52,7 +67,7 @@ pub(crate) unconstrained fn handshake_registry_sync(
     offchain_inbox_sync: Option<OffchainInboxSync>,
     scope: AztecAddress,
 ) {
-    let cursor = capsules::load::<u32>(contract_address, SYNC_CURSOR_CAPSULE_SLOT, scope);
+    let cursor = load_sync_cursor(contract_address, scope);
     let anchor_block = UtilityContext::new().block_number();
 
     // `to_block` is exclusive, so we add 1 to include the anchor block in the scan
@@ -63,26 +78,18 @@ pub(crate) unconstrained fn handshake_registry_sync(
         let tag = compute_log_tag(scope.to_field(), DOM_SEP__NON_INTERACTIVE_HANDSHAKE_LOG_TAG);
         let logs = get_handshake_logs_in_range(contract_address, tag, cursor, Option::some(next_block));
 
-        // Store all valid handshakes
-        let handshakes: CapsuleArray<DiscoveredHandshake> =
-            CapsuleArray::at(contract_address, HANDSHAKES_CAPSULE_SLOT, scope);
+        // Record all valid handshakes
         logs.for_each(|_i, log| {
             let ciphertext = aztec::utils::array::subbvec(log.log_payload, 0);
 
             let _ = AES128::decrypt(ciphertext, scope, contract_address)
                 .and_then(|pt| {
                     point_from_x_coord_and_sign(pt.get(0), true).map(|pk| DiscoveredHandshake { eph_pk: pk })
                 })
-                .map(|h| handshakes.push(h));
+                .map(|h| record_discovered_handshake(contract_address, scope, h, log.block_number));
         });
 
-        // Update the cursor
-        capsules::store(
-            contract_address,
-            SYNC_CURSOR_CAPSULE_SLOT,
-            next_block,
-            scope,
-        );
+        store_sync_cursor(contract_address, scope, anchor_block);
     }
 
     do_sync_state_without_handshake_discovery(
@@ -95,12 +102,99 @@ pub(crate) unconstrained fn handshake_registry_sync(
     );
 }
 
-/// Returns the capsule array of discovered handshakes for `recipient`.
+/// Returns the discovered handshakes for `recipient`, one per canonical handshake fact collection.
+///
+/// Ordering is unspecified.
 pub(crate) unconstrained fn get_all_handshakes(
     contract_address: AztecAddress,
     recipient: AztecAddress,
-) -> CapsuleArray<DiscoveredHandshake> {
-    CapsuleArray::at(contract_address, HANDSHAKES_CAPSULE_SLOT, recipient)
+) -> EphemeralArray<DiscoveredHandshake> {
+    get_fact_collections_by_type(contract_address, recipient, DISCOVERED_HANDSHAKES_TYPE_ID)
+        .map(|collection: FactCollection| {
+            let fact = collection.facts.find(|f: Fact| f.fact_type_id == HANDSHAKE_DISCOVERED).unwrap();
+            handshake_from_payload(fact.payload)
+        })
+}
+
+/// Records a discovered handshake as a retractable fact originated at the block its announcement log landed in.
+///
+/// The collection id is a hash of the handshake, so re-recording the same handshake at the same origin (e.g. when
+/// rescanning after the cursor was retracted by a reorg) is a no-op, and the same `eph_pk` can never appear twice.
+unconstrained fn record_discovered_handshake(
+    contract_address: AztecAddress,
+    scope: AztecAddress,
+    handshake: DiscoveredHandshake,
+    block_number: u32,
+) {
+    record_retractable_fact(
+        contract_address,
+        scope,
+        DISCOVERED_HANDSHAKES_TYPE_ID,
+        handshake_collection_id(handshake),
+        HANDSHAKE_DISCOVERED,
+        handshake_to_payload(handshake),
+        // The log retrieval oracle intentionally exposes only the origin block number, and FactStore retraction and
+        // origin-state classification key on block number alone, so no real hash is available or needed.
+        OriginBlock { block_number, block_hash: 0 },
+    );
+}
+
+/// Computes the fact-collection id identifying `handshake` in the [fact store](aztec::facts).
+fn handshake_collection_id(handshake: DiscoveredHandshake) -> Field {
+    poseidon2_hash(handshake.serialize())
+}
+
+/// Serializes a [`DiscoveredHandshake`] into a fact payload.
+unconstrained fn handshake_to_payload(handshake: DiscoveredHandshake) -> EphemeralArray<Field> {
+    let fields = handshake.serialize();
+    let payload: EphemeralArray<Field> = EphemeralArray::empty();
+    for i in 0..fields.len() {
+        payload.push(fields[i]);
+    }
+    payload
+}
+
+/// Deserializes a [`DiscoveredHandshake`] from a fact payload.
+unconstrained fn handshake_from_payload(payload: EphemeralArray<Field>) -> DiscoveredHandshake {
+    let n = <DiscoveredHandshake as Deserialize>::N;
+    let mut fields = [0; <DiscoveredHandshake as Deserialize>::N];
+    for i in 0..n {
+        fields[i] = payload.get(i);
+    }
+    Deserialize::deserialize(fields)
+}
+
+/// Returns the next block (inclusive) the discovery scan should start from, or `None` if no canonical cursor exists,
+/// either because this scope never synced or because the cursor fact's origin block was reorg'd away. In the latter
+/// case the caller rescans the full range and fact idempotency deduplicates re-discovered handshakes.
+unconstrained fn load_sync_cursor(contract_address: AztecAddress, scope: AztecAddress) -> Option<u32> {
+    get_fact_collection(
+        contract_address,
+        scope,
+        SYNC_CURSOR_TYPE_ID,
+        SYNC_CURSOR_COLLECTION_ID,
+    )
+        .map(|collection: FactCollection| collection.facts.get(0).origin_block.unwrap().block_number + 1)
+}
+
+/// Replaces the cursor fact with one originated at `anchor_block` (the block the completed scan ran against), so a
+/// reorg pruning any scanned block also retracts the cursor and the next sync rescans.
+unconstrained fn store_sync_cursor(contract_address: AztecAddress, scope: AztecAddress, anchor_block: u32) {
+    delete_fact_collection(
+        contract_address,
+        scope,
+        SYNC_CURSOR_TYPE_ID,
+        SYNC_CURSOR_COLLECTION_ID,
+    );
+    record_retractable_fact(
+        contract_address,
+        scope,
+        SYNC_CURSOR_TYPE_ID,
+        SYNC_CURSOR_COLLECTION_ID,
+        SYNC_CURSOR,
+        EphemeralArray::empty(),
+        OriginBlock { block_number: anchor_block, block_hash: 0 },
+    );
 }
 
 /// Fetches all private logs emitted under `tag` in the block range `[from_block, to_block)`.

noir-projects/noir-contracts/contracts/standard/handshake_registry_contract/src/test.nr

@@ -1,6 +1,8 @@
 use crate::HandshakeRegistry;
+use crate::sync::{DISCOVERED_HANDSHAKES_TYPE_ID, SYNC_CURSOR_COLLECTION_ID, SYNC_CURSOR_TYPE_ID};
 
 use aztec::{
+    facts::{delete_fact_collection, get_fact_collections_by_type},
     messages::delivery::{
         constrained_delivery::VALIDATE_HANDSHAKE_SELECTOR,
         handshake::{
@@ -485,7 +487,7 @@ unconstrained fn repeated_sync_does_not_refetch_logs() {
     assert_eq(after_first.items.len(), 1);
 
     // Mock the log-retrieval oracle so we can assert it is never called on re-sync.
-    let log_oracle = OracleMock::mock("aztec_utl_getLogsByTag");
+    let log_oracle = OracleMock::mock("aztec_utl_getLogsByTagV2");
     let _ = env.execute_utility(registry.get_handshakes(recipient, 0));
     assert_eq(log_oracle.times_called(), 0);
     log_oracle.clear();
@@ -554,3 +556,56 @@ unconstrained fn get_handshakes_out_of_bounds_offset_returns_empty() {
     assert_eq(page.items.len(), 0);
     assert_eq(page.total_count, 1);
 }
+
+// The cursor fact is retractable: a reorg pruning its origin block deletes it, forcing the next sync to rescan the
+// full range. Simulate that state by deleting the cursor collection and verify the rescan does not duplicate
+// handshakes whose facts survived (they are content-addressed, so re-recording them is a no-op).
+#[test]
+unconstrained fn rescan_after_cursor_retraction_does_not_duplicate_handshakes() {
+    let (env, registry_address, sender, _, recipient) = setup();
+    let registry = HandshakeRegistry::at(registry_address);
+
+    let _ = env.call_private(sender, registry.non_interactive_handshake(sender, recipient));
+
+    let after_first = env.execute_utility(registry.get_handshakes(recipient, 0));
+    assert_eq(after_first.items.len(), 1);
+
+    env.utility_context_at(registry_address, |_| delete_fact_collection(
+        registry_address,
+        recipient,
+        SYNC_CURSOR_TYPE_ID,
+        SYNC_CURSOR_COLLECTION_ID,
+    ));
+    // Advance the anchor so a fact wrongly originated at the sync anchor would get a distinct origin and duplicate.
+    env.mine_block();
+
+    let after_rescan = env.execute_utility(registry.get_handshakes(recipient, 0));
+    assert_eq(after_rescan.items.len(), 1);
+    assert_eq(after_rescan.items.get(0).eph_pk.x, after_first.items.get(0).eph_pk.x);
+}
+
+// The handshake fact must originate at the block its announcement log landed in (not the sync anchor) so a reorg
+// retracts exactly the handshakes carried by pruned blocks.
+#[test]
+unconstrained fn handshake_fact_originates_at_the_log_block() {
+    let (env, registry_address, sender, _, recipient) = setup();
+    let registry = HandshakeRegistry::at(registry_address);
+
+    let _ = env.call_private(sender, registry.non_interactive_handshake(sender, recipient));
+    let handshake_block = env.last_block_number();
+
+    // Advance the chain so the sync anchor is later than the block carrying the handshake log.
+    env.mine_block();
+    env.mine_block();
+
+    let discovered = env.execute_utility(registry.get_handshakes(recipient, 0));
+    assert_eq(discovered.items.len(), 1);
+
+    // Ephemeral arrays are frame-scoped, so read the fact and extract the origin inside the registry's context.
+    let origin_block_number = env.utility_context_at(registry_address, |_| {
+        let collections = get_fact_collections_by_type(registry_address, recipient, DISCOVERED_HANDSHAKES_TYPE_ID);
+        assert_eq(collections.len(), 1);
+        collections.get(0).facts.get(0).origin_block.unwrap().block_number
+    });
+    assert_eq(origin_block_number, handshake_block);
+}

noir-projects/noir-contracts/pinned-standard-contracts.tar.gz

@@ -20,44 +20,44 @@ export const StandardContractSalt: Record<StandardContractName, Fr> = {
 };
 
 export const StandardContractAddress: Record<StandardContractName, AztecAddress> = {
-  AuthRegistry: AztecAddress.fromStringUnsafe('0x186fbbe15f50d01d67c471d5ed8b8be43b8826e77147cb0084302804e336e5d2'),
+  AuthRegistry: AztecAddress.fromStringUnsafe('0x2e5ddde017507a7faa104e9a26584bfcfb91873412ac912e127fc0280e96d44f'),
   MultiCallEntrypoint: AztecAddress.fromStringUnsafe(
-    '0x10a91e72a359e7441d4af9e418f14862abe994348970909d484ff2dad1594a58',
+    '0x19cd5344d6da9545c5bed85045f33c3db45abd5bbb2ca54b110bd29f53503d70',
   ),
-  PublicChecks: AztecAddress.fromStringUnsafe('0x1f6f565db58df81c2bbb8e9932fa92d2d1f537887a06e2cb965184f77a5235d2'),
+  PublicChecks: AztecAddress.fromStringUnsafe('0x2af70394e3fe40203bc3271bc8e1ad9d6e8c9ffb547a354aaab7f1aca63c8697'),
   HandshakeRegistry: AztecAddress.fromStringUnsafe(
-    '0x18233660a8797d74f63318c4223332e23b63f570da11fb142993ebc802a96728',
+    '0x171fcd1d024cc5b3273945e50d7e6eb715dab71f2e13cb6dfc49a3ca6fc8642f',
   ),
 };
 
 export const StandardContractClassId: Record<StandardContractName, Fr> = {
-  AuthRegistry: Fr.fromString('0x1684ac4f8c250f8ecc1c7629a344fa36002f5130d3b1bbe6e2c0e73e14640f0a'),
-  MultiCallEntrypoint: Fr.fromString('0x003a615f16c5401ef184876baf2aa54f67ff693672a03134cc8920cfb58957c7'),
-  PublicChecks: Fr.fromString('0x086e79a9008498c03a83dd1e9b69b6cbe8d1fafe31b2a775d0b6610dac7d681c'),
-  HandshakeRegistry: Fr.fromString('0x1007fb490420810f54215128260e808c7ab2b1dc4c1801156833d4720696bf31'),
+  AuthRegistry: Fr.fromString('0x2f6b1e4de76f5082a87a416ef1e0d87cdb43bd01bdbce95c5b8e0a9ecab592ad'),
+  MultiCallEntrypoint: Fr.fromString('0x1d1bf60ebb7e3d4fd38eb0de5bfe71ced78f47533fb6fd2b07c1fa1d430463c7'),
+  PublicChecks: Fr.fromString('0x0b018b124a3757f765634cb805914c5af46bec0bd91647f617f1056a5508460f'),
+  HandshakeRegistry: Fr.fromString('0x096b9c0fa53c09a8969471b5b78d5812385bd056650febc03852bf80724ea30a'),
 };
 
 export const StandardContractClassIdPreimage: Record<
   StandardContractName,
   { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }
 > = {
   AuthRegistry: {
-    artifactHash: Fr.fromString('0x175607a9b31428948f4041db7d4e1667492292fb7850f8138c1d3cf5ffde8b34'),
+    artifactHash: Fr.fromString('0x1e0d42f3e2cc6a510110e2ddafd909691038754134610e6306813d34240bc176'),
     privateFunctionsRoot: Fr.fromString('0x17b584350f4c3ccafd8f688729afb9feab8976114fb40012e9dee65022c072a4'),
     publicBytecodeCommitment: Fr.fromString('0x2545f39893766508ce37bb5cea5e4dcab04c6f7f79f3089b1c076876e9d268b2'),
   },
   MultiCallEntrypoint: {
-    artifactHash: Fr.fromString('0x23af448187164c7d5e6f392346958e688690370515359de8909f3f05f2e26760'),
+    artifactHash: Fr.fromString('0x2377af88372bbb2961478e296d4c888aa3748b8e8606d282fcadd745308f8444'),
     privateFunctionsRoot: Fr.fromString('0x0e68dfbb256e80b08b3aef47aca1f2669e97a9c6259787893c1223ac083ad5d5'),
     publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
   },
   PublicChecks: {
-    artifactHash: Fr.fromString('0x2f3869d9d89bf7b428da7f8c620aea11acc022cc0c7222544cc841e5ceedd8dc'),
+    artifactHash: Fr.fromString('0x0ab0b0a0fdf8b8646b7a1a574da6691f3ddf82d07ad55053e41fa0c5a37971ff'),
     privateFunctionsRoot: Fr.fromString('0x202860adb1b8975971eeaf571aaaa88a27f4035290d58532ae7d60b0dfaad54c'),
     publicBytecodeCommitment: Fr.fromString('0x013c4f854a5c87c9daf86c5f9bc07a42c2a061f1d924a5b3564ec7edc8e18cb7'),
   },
   HandshakeRegistry: {
-    artifactHash: Fr.fromString('0x080bd5c37240f9425fea5c87b844a67ffda312dbf58c58288b7ba6b4d5db7663'),
+    artifactHash: Fr.fromString('0x1ad17c0563153f1d495e906b5e6dbee256ff0d9a51c65c7dc48327247d2b2758'),
     privateFunctionsRoot: Fr.fromString('0x14fed008fa16ae6e45b7561aa0101d0d97953e2fd86caf7aaa603f14807797a8'),
     publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
   },