feat: store discovered handshakes as facts (#24483)

Author: vezenovm

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

@@ -19,4 +19,10 @@ 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 number of 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,
+    /// The hash of the block in which `tx_hash` was included
+    pub block_hash: Field,
 }

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/oracle/version.nr

@@ -11,7 +11,7 @@
 /// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency
 /// without actually using any of the new oracles then there is no reason to throw.
 pub global ORACLE_VERSION_MAJOR: Field = 30;
-pub global ORACLE_VERSION_MINOR: Field = 3;
+pub global ORACLE_VERSION_MINOR: Field = 4;
 
 /// Asserts that the version of the oracle is compatible with the version expected by the contract.
 pub fn assert_compatible_oracle_version() {

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(
-    0x0f53c9d679c6aa851b46bfc07e14bd070d5948b6ad1a4f7c54909f61dceb146a,
+    0x0564d5361fd6d7501baa1706a59bbebd2035d1c2565c9e5daf8f1567da547a23,
 );
 
 pub global STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x251d9cb1aa645672268b9b9082dedba22986ba9068d5ad8ecfae53f24e16c109,
+    0x126ab69e8161771b52273d00dbf5d7252ef6a92724d15f1ec2dcc967118a0c7b,
 );
 
 pub global STANDARD_PUBLIC_CHECKS_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x2ebeb911fc3963e7d1869af2dc7fee318d1edbc957edb46a0e99b46867ba4492,
+    0x077341cf79b91db9c440c49786fc4d4508ef3ab623c30fa3be7031ffcad4754c,
 );
 
 pub global STANDARD_HANDSHAKE_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x1523a141a33e5aa8d72624823b8592b87799c9ee0c086dd9f3c80661905366ab,
+    0x2f8592fb5b1620f33d21d9b67a34002f0e5392d93807a684584af388e0d70741,
 );

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

@@ -35,7 +35,7 @@ global INTERACTIVE_HANDSHAKE: u8 = 2;
 pub contract HandshakeRegistry {
     use crate::{
         handshake_note::HandshakeNote, INTERACTIVE_HANDSHAKE, NON_INTERACTIVE_HANDSHAKE,
-        recipient_signature::RecipientSignature, sync::get_all_handshakes,
+        recipient_signature::RecipientSignature, sync::discovered_handshakes::get_all_handshakes,
     };
     use aztec::{
         keys::{ecdh_shared_secret::derive_ecdh_shared_secret, ephemeral::generate_positive_ephemeral_key_pair},

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

@@ -0,0 +1,64 @@
+use crate::sync::rewindable_register::RewindableRegister;
+use aztec::{
+    facts::{delete_fact_collection, OriginBlock},
+    protocol::{abis::block_header::BlockHeader, address::AztecAddress, hash::sha256_to_field, traits::Hash},
+};
+
+/// Fact-collection type id of the per-recipient sync cursor: a [`RewindableRegister`] holding the anchor block of
+/// the last completed scan.
+global SYNC_CURSOR_TYPE_ID: Field = sha256_to_field("HANDSHAKE_REGISTRY::SYNC_CURSOR".as_bytes());
+
+/// Collection id of the singleton cursor register.
+global SYNC_CURSOR_COLLECTION_ID: Field = 0;
+
+/// Reorg-aware cursor tracking the last scanned anchor block of a recipient's handshake sync.
+pub(crate) struct SyncCursor {
+    contract_address: AztecAddress,
+    scope: AztecAddress,
+}
+
+impl SyncCursor {
+    /// Returns the cursor of `scope`'s handshake sync in the given contract.
+    pub(crate) unconstrained fn at(contract_address: AztecAddress, scope: AztecAddress) -> Self {
+        Self { contract_address, scope }
+    }
+
+    /// Returns the first block the next scan must cover, or `None` to scan from genesis.
+    ///
+    /// The next scan starts one past the last completed scan's anchor block. `None` means no scan ever completed, or
+    /// a reorg rolled back every recorded one.
+    pub(crate) unconstrained fn next_block_to_scan(self) -> Option<u32> {
+        self.register().read().map(|anchor| anchor + 1)
+    }
+
+    /// Records a completed scan up to the given anchor block.
+    ///
+    /// The cursor originates at the scanned anchor block itself, so a reorg pruning that block rolls the cursor back
+    /// to the last surviving scan and the pruned range gets covered again.
+    pub(crate) unconstrained fn advance(self, anchor_block_header: BlockHeader) {
+        self.register().write(
+            anchor_block_header.block_number(),
+            OriginBlock { block_number: anchor_block_header.block_number(), block_hash: anchor_block_header.hash() },
+        );
+    }
+
+    /// Forgets every recorded scan, as if no sync had ever completed. Only used by tests, to emulate a reorg
+    /// retracting every recorded scan.
+    pub(crate) unconstrained fn clear(self) {
+        delete_fact_collection(
+            self.contract_address,
+            self.scope,
+            SYNC_CURSOR_TYPE_ID,
+            SYNC_CURSOR_COLLECTION_ID,
+        );
+    }
+
+    unconstrained fn register(self) -> RewindableRegister<u32> {
+        RewindableRegister::at(
+            self.contract_address,
+            self.scope,
+            SYNC_CURSOR_TYPE_ID,
+            SYNC_CURSOR_COLLECTION_ID,
+        )
+    }
+}

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

@@ -0,0 +1,74 @@
+use crate::sync::rewindable_register::{deserialize_payload, serialize_payload};
+use aztec::{
+    ephemeral::EphemeralArray,
+    facts::{get_fact_collection, OriginBlock, record_retractable_fact},
+    messages::delivery::handshake::DiscoveredHandshake,
+    protocol::{address::AztecAddress, hash::sha256_to_field},
+};
+
+/// Fact-collection type id of the per-recipient discovered handshakes populated by [`record_discovered_handshake`]
+/// and read by [`get_all_handshakes`]. Each recipient (the fact scope) has a single collection of this type holding
+/// one fact per discovered handshake, in discovery order.
+global DISCOVERED_HANDSHAKES_TYPE_ID: Field = sha256_to_field("HANDSHAKE_REGISTRY::DISCOVERED_HANDSHAKES".as_bytes());
+
+/// Collection id of the singleton discovered-handshakes collection.
+global DISCOVERED_HANDSHAKES_COLLECTION_ID: Field = 0;
+
+/// Fact type id of the fact storing a serialized [`DiscoveredHandshake`] inside the discovered-handshakes collection.
+global HANDSHAKE_DISCOVERED: Field = sha256_to_field("HANDSHAKE_REGISTRY::HANDSHAKE_DISCOVERED".as_bytes());
+
+/// Records a discovered handshake for `recipient`.
+///
+/// The handshake originates at the block its announcement log landed in, so a reorg pruning that block makes the
+/// handshake invisible again. Fact identity covers the payload and origin block, so re-recording the same handshake
+/// at the same origin is a no-op.
+pub(crate) unconstrained fn record_discovered_handshake(
+    contract_address: AztecAddress,
+    recipient: AztecAddress,
+    handshake: DiscoveredHandshake,
+    origin_block: OriginBlock,
+) {
+    record_retractable_fact(
+        contract_address,
+        recipient,
+        DISCOVERED_HANDSHAKES_TYPE_ID,
+        DISCOVERED_HANDSHAKES_COLLECTION_ID,
+        HANDSHAKE_DISCOVERED,
+        serialize_payload(handshake),
+        origin_block,
+    );
+}
+
+/// Returns the discovered handshakes for `recipient`.
+///
+/// The order of facts within a collection is not specified, but it is stable, keeping
+/// [`HandshakeRegistry::get_handshakes`] pagination consistent across pages.
+pub(crate) unconstrained fn get_all_handshakes(
+    contract_address: AztecAddress,
+    recipient: AztecAddress,
+) -> EphemeralArray<DiscoveredHandshake> {
+    get_fact_collection(
+        contract_address,
+        recipient,
+        DISCOVERED_HANDSHAKES_TYPE_ID,
+        DISCOVERED_HANDSHAKES_COLLECTION_ID,
+    )
+        .map_or(EphemeralArray::empty(), |collection| collection.facts.map(|fact| deserialize_payload(fact.payload)))
+}
+
+/// Returns the origin block number of each of `recipient`'s discovered handshakes. Only used by tests, to assert
+/// that handshake facts originate at the log's block rather than the sync anchor.
+pub(crate) unconstrained fn origin_block_numbers(
+    contract_address: AztecAddress,
+    recipient: AztecAddress,
+) -> EphemeralArray<u32> {
+    get_fact_collection(
+        contract_address,
+        recipient,
+        DISCOVERED_HANDSHAKES_TYPE_ID,
+        DISCOVERED_HANDSHAKES_COLLECTION_ID,
+    )
+        .map_or(EphemeralArray::empty(), |collection| {
+            collection.facts.map(|fact| fact.origin_block.unwrap().block_number)
+        })
+}

…/handshake_registry_contract/src/sync.nr …dshake_registry_contract/src/sync/mod.nrnoir-projects/noir-contracts/contracts/standard/handshake_registry_contract/src/sync.nr renamed to noir-projects/noir-contracts/contracts/standard/handshake_registry_contract/src/sync/mod.nr noir-projects/noir-contracts/contracts/standard/handshake_registry_contract/src/sync.nr renamed to noir-projects/noir-contracts/contracts/standard/handshake_registry_contract/src/sync/mod.nr

@@ -1,7 +1,12 @@
+pub(crate) mod cursor;
+pub(crate) mod discovered_handshakes;
+pub(crate) mod rewindable_register;
+
+use crate::sync::{cursor::SyncCursor, discovered_handshakes::record_discovered_handshake};
 use aztec::{
-    capsules::CapsuleArray,
     context::UtilityContext,
     ephemeral::EphemeralArray,
+    facts::OriginBlock,
     messages::{
         delivery::handshake::DiscoveredHandshake,
         discovery::{
@@ -14,7 +19,7 @@ use aztec::{
             offchain::OffchainInboxSync,
         },
     },
-    oracle::{capsules, message_processing},
+    oracle::message_processing,
     protocol::{
         address::AztecAddress,
         constants::DOM_SEP__NON_INTERACTIVE_HANDSHAKE_LOG_TAG,
@@ -24,25 +29,18 @@ use aztec::{
     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());
-
-/// 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());
-
 /// 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 =
     sha256_to_field("HANDSHAKE_REGISTRY::LOG_RETRIEVAL_REQUEST_ARRAY".as_bytes());
 
 /// 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,37 +50,36 @@ 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 anchor_block = UtilityContext::new().block_number();
+    let cursor = SyncCursor::at(contract_address, scope);
+    let from_block = cursor.next_block_to_scan();
+    let anchor_block_header = UtilityContext::new().block_header();
+    let anchor_block = anchor_block_header.block_number();
 
     // `to_block` is exclusive, so we add 1 to include the anchor block in the scan
     let next_block = anchor_block + 1;
-    let should_scan = cursor.map(|c| c != next_block).unwrap_or(true);
+    let should_scan = from_block.map(|b| b != next_block).unwrap_or(true);
     if should_scan {
         // Find all handshakes for the given recipient
         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));
+        let logs = get_handshake_logs_in_range(contract_address, tag, from_block, 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,
+                    OriginBlock { block_number: log.block_number, block_hash: log.block_hash },
+                ));
         });
 
-        // Update the cursor
-        capsules::store(
-            contract_address,
-            SYNC_CURSOR_CAPSULE_SLOT,
-            next_block,
-            scope,
-        );
+        cursor.advance(anchor_block_header);
     }
 
     do_sync_state_without_handshake_discovery(
@@ -95,14 +92,6 @@ pub(crate) unconstrained fn handshake_registry_sync(
     );
 }
 
-/// Returns the capsule array of discovered handshakes for `recipient`.
-pub(crate) unconstrained fn get_all_handshakes(
-    contract_address: AztecAddress,
-    recipient: AztecAddress,
-) -> CapsuleArray<DiscoveredHandshake> {
-    CapsuleArray::at(contract_address, HANDSHAKES_CAPSULE_SLOT, recipient)
-}
-
 /// Fetches all private logs emitted under `tag` in the block range `[from_block, to_block)`.
 ///
 /// Thin wrapper around [`message_processing::get_logs_by_tag`] that batches a single request and unwraps the single