feat: remove nullifiers from SyncState endpoint (#708)

* feat: add block_num parameter to check_nullifiers_by_prefix * chore: update CHANGELOG * review: add `block_num` parameter as required * review: update CHANGELOG * review: update doc comment * feat: remove nullifiers from `SyncState` endpoint * chore: update doc comments * chore: update CHANGELOG * chore: update rpc README
0xPolygonMiden · Feb 20, 2025 · 098b422 · 098b422
1 parent 73884ff
commit 098b422
Show file tree

Hide file tree

Showing 16 changed files with 182 additions and 572 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -18,6 +18,7 @@
 - [BREAKING] Updated minimum Rust version to 1.84.
 - [BREAKING] `Endpoint` configuration simplified to a single string (#654).
 - [BREAKING] `CheckNullifiersByPrefix` now takes a starting block number (#707).
+- [BREAKING] Removed nullifiers from `SyncState` endpoint (#708).
 
 ### Enhancements
 

diff --git a/crates/proto/src/generated/requests.rs b/crates/proto/src/generated/requests.rs
@@ -45,7 +45,7 @@ pub struct GetBlockHeaderByNumberRequest {
 ///
 /// Specifies state updates the client is interested in. The server will return the first block which
 /// contains a note matching `note_tags` or the chain tip. And the corresponding updates to
-/// `nullifiers` and `account_ids` for that block range.
+/// `account_ids` for that block range.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SyncStateRequest {
     /// Last block known by the client. The response will contain data starting from the next block,
@@ -63,10 +63,6 @@ pub struct SyncStateRequest {
     /// Specifies the tags which the client is interested in.
     #[prost(fixed32, repeated, tag = "3")]
     pub note_tags: ::prost::alloc::vec::Vec<u32>,
-    /// Determines the nullifiers the client is interested in by specifying the 16high bits of the
-    /// target nullifier.
-    #[prost(uint32, repeated, tag = "4")]
-    pub nullifiers: ::prost::alloc::vec::Vec<u32>,
 }
 /// Note synchronization request.
 ///

diff --git a/crates/proto/src/generated/responses.rs b/crates/proto/src/generated/responses.rs
@@ -61,9 +61,6 @@ pub struct SyncStateResponse {
     /// List of all notes together with the Merkle paths from `response.block_header.note_root`.
     #[prost(message, repeated, tag = "7")]
     pub notes: ::prost::alloc::vec::Vec<super::note::NoteSyncRecord>,
-    /// List of nullifiers created between `request.block_num + 1` and `response.block_header.block_num`.
-    #[prost(message, repeated, tag = "8")]
-    pub nullifiers: ::prost::alloc::vec::Vec<NullifierUpdate>,
 }
 /// Represents the result of syncing notes request.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -124,9 +121,7 @@ pub struct GetBlockInputsResponse {
     pub nullifiers: ::prost::alloc::vec::Vec<NullifierBlockInputRecord>,
     /// The list of requested notes which were found in the database.
     #[prost(message, optional, tag = "5")]
-    pub found_unauthenticated_notes: ::core::option::Option<
-        super::note::NoteAuthenticationInfo,
-    >,
+    pub found_unauthenticated_notes: ::core::option::Option<super::note::NoteAuthenticationInfo>,
 }
 /// Represents the result of getting batch inputs.
 #[derive(Clone, PartialEq, ::prost::Message)]

diff --git a/crates/proto/src/generated/rpc.rs b/crates/proto/src/generated/rpc.rs
diff --git a/crates/rpc-proto/proto/requests.proto b/crates/rpc-proto/proto/requests.proto
@@ -43,7 +43,7 @@ message GetBlockHeaderByNumberRequest {
 //
 // Specifies state updates the client is interested in. The server will return the first block which
 // contains a note matching `note_tags` or the chain tip. And the corresponding updates to
-// `nullifiers` and `account_ids` for that block range.
+// `account_ids` for that block range.
 message SyncStateRequest {
     // Last block known by the client. The response will contain data starting from the next block,
     // until the first block which contains a note of matching the requested tag, or the chain tip
@@ -59,10 +59,6 @@ message SyncStateRequest {
 
     // Specifies the tags which the client is interested in.
     repeated fixed32 note_tags = 3;
-
-    // Determines the nullifiers the client is interested in by specifying the 16high bits of the
-    // target nullifier.
-    repeated uint32 nullifiers = 4;
 }
 
 // Note synchronization request.

diff --git a/crates/rpc-proto/proto/responses.proto b/crates/rpc-proto/proto/responses.proto
@@ -66,9 +66,6 @@ message SyncStateResponse {
 
     // List of all notes together with the Merkle paths from `response.block_header.note_root`.
     repeated note.NoteSyncRecord notes = 7;
-
-    // List of nullifiers created between `request.block_num + 1` and `response.block_header.block_num`.
-    repeated NullifierUpdate nullifiers = 8;
 }
 
 // Represents the result of syncing notes request.

diff --git a/crates/rpc-proto/proto/rpc.proto b/crates/rpc-proto/proto/rpc.proto
@@ -49,19 +49,19 @@ service Api {
     rpc SyncNotes(requests.SyncNoteRequest) returns (responses.SyncNoteResponse) {}
 
     // Returns info which can be used by the client to sync up to the latest state of the chain
-    // for the objects (accounts, notes, nullifiers) the client is interested in.
+    // for the objects (accounts and notes) the client is interested in.
     //
     // This request returns the next block containing requested data. It also returns `chain_tip`
     // which is the latest block number in the chain. Client is expected to repeat these requests
     // in a loop until `response.block_header.block_num == response.chain_tip`, at which point
     // the client is fully synchronized with the chain.
     //
-    // Each request also returns info about new notes, nullifiers etc. created. It also returns
+    // Each update response also contains info about new notes, accounts etc. created. It also returns
     // Chain MMR delta that can be used to update the state of Chain MMR. This includes both chain
     // MMR peaks and chain MMR nodes.
     //
-    // For preserving some degree of privacy, note tags and nullifiers filters contain only high
-    // part of hashes. Thus, returned data contains excessive notes and nullifiers, client can make
+    // For preserving some degree of privacy, note tags contain only high
+    // part of hashes. Thus, returned data contains excessive notes, client can make
     // additional filtering of that data on its side.
     rpc SyncState(requests.SyncStateRequest) returns (responses.SyncStateResponse) {}
 }
diff --git a/crates/rpc/README.md b/crates/rpc/README.md
@@ -102,18 +102,17 @@ the chain.
 
 ### SyncState
 
-Returns info which can be used by the client to sync up to the latest state of the chain for the objects (accounts,
-notes, nullifiers) the client is interested in.
+Returns info which can be used by the client to sync up to the latest state of the chain for the objects (accounts 
+and notes) the client is interested in.
 
-This request returns the next block containing requested data. It also returns `chain_tip` which is the latest block
-number in the chain. Client is expected to repeat these requests in a loop until
-`response.block_header.block_num == response.chain_tip`, at which point the client is fully synchronized with the chain.
+This request returns a stream where multiple update responses will be pushed in order. Client is expected to read 
+the updates from the stream and apply them, and then it will be fully synchronized with the chain.
 
-Each request also returns info about new notes, nullifiers etc. created. It also returns Chain MMR delta that can be
-used to update the state of Chain MMR. This includes both chain MMR peaks and chain MMR nodes.
+Each update response also contains info about new notes, accounts etc. created. It also returns Chain MMR delta 
+that can be used to update the state of Chain MMR. This includes both chain MMR peaks and chain MMR nodes.
 
-For preserving some degree of privacy, note tags and nullifiers filters contain only high part of hashes. Thus, returned
-data contains excessive notes and nullifiers, client can make additional filtering of that data on its side.
+For preserving some degree of privacy, note tags contain only high part of hashes. Thus, returned data contains 
+excessive notes, client can make additional filtering of that data on its side.
 
 ---
 

diff --git a/crates/store/src/db/mod.rs b/crates/store/src/db/mod.rs
@@ -85,7 +85,6 @@ pub struct StateSyncUpdate {
     pub block_header: BlockHeader,
     pub account_updates: Vec<AccountSummary>,
     pub transactions: Vec<TransactionSummary>,
-    pub nullifiers: Vec<NullifierInfo>,
 }
 
 #[derive(Debug, PartialEq)]
@@ -328,15 +327,12 @@ impl Db {
         block_num: BlockNumber,
         account_ids: Vec<AccountId>,
         note_tags: Vec<u32>,
-        nullifier_prefixes: Vec<u32>,
     ) -> Result<StateSyncUpdate, StateSyncError> {
         self.pool
             .get()
             .await
             .map_err(DatabaseError::MissingDbConnection)?
-            .interact(move |conn| {
-                sql::get_state_sync(conn, block_num, &account_ids, &note_tags, &nullifier_prefixes)
-            })
+            .interact(move |conn| sql::get_state_sync(conn, block_num, &account_ids, &note_tags))
             .await
             .map_err(|err| {
                 DatabaseError::InteractError(format!("Get state sync task failed: {err}"))

diff --git a/crates/store/src/db/sql/mod.rs b/crates/store/src/db/sql/mod.rs
@@ -617,54 +617,6 @@ pub fn select_all_nullifiers(conn: &mut Connection) -> Result<Vec<(Nullifier, Bl
     Ok(result)
 }
 
-/// Select nullifiers created between `(block_start, block_end]` that also match the
-/// `nullifier_prefixes` filter using the given [Connection].
-///
-/// Each value of the `nullifier_prefixes` is only the 16 most significant bits of the nullifier of
-/// interest to the client. This hides the details of the specific nullifier being requested.
-///
-/// # Returns
-///
-/// A vector of [`NullifierInfo`] with the nullifiers and the block height at which they were
-/// created, or an error.
-pub fn select_nullifiers_by_block_range(
-    conn: &mut Connection,
-    block_start: BlockNumber,
-    block_end: BlockNumber,
-    nullifier_prefixes: &[u32],
-) -> Result<Vec<NullifierInfo>> {
-    let nullifier_prefixes: Vec<Value> =
-        nullifier_prefixes.iter().copied().map(Into::into).collect();
-
-    let mut stmt = conn.prepare_cached(
-        "
-        SELECT
-            nullifier,
-            block_num
-        FROM
-            nullifiers
-        WHERE
-            block_num > ?1 AND
-            block_num <= ?2 AND
-            nullifier_prefix IN rarray(?3)
-        ORDER BY
-            block_num ASC
-    ",
-    )?;
-
-    let mut rows =
-        stmt.query(params![block_start.as_u32(), block_end.as_u32(), Rc::new(nullifier_prefixes)])?;
-
-    let mut result = Vec::new();
-    while let Some(row) = rows.next()? {
-        let nullifier_data = row.get_ref(0)?.as_blob()?;
-        let nullifier = Nullifier::read_from_bytes(nullifier_data)?;
-        let block_num: u32 = row.get(1)?;
-        result.push(NullifierInfo { nullifier, block_num: block_num.into() });
-    }
-    Ok(result)
-}
-
 /// Returns nullifiers filtered by prefix and block creation height.
 ///
 /// Each value of the `nullifier_prefixes` is only the `prefix_len` most significant bits
@@ -1195,7 +1147,6 @@ pub fn get_state_sync(
     block_num: BlockNumber,
     account_ids: &[AccountId],
     note_tag_prefixes: &[u32],
-    nullifier_prefixes: &[u32],
 ) -> Result<StateSyncUpdate, StateSyncError> {
     let notes = select_notes_since_block_by_tag_and_sender(
         conn,
@@ -1218,19 +1169,11 @@ pub fn get_state_sync(
         account_ids,
     )?;
 
-    let nullifiers = select_nullifiers_by_block_range(
-        conn,
-        block_num,
-        block_header.block_num(),
-        nullifier_prefixes,
-    )?;
-
     Ok(StateSyncUpdate {
         notes,
         block_header,
         account_updates,
         transactions,
-        nullifiers,
     })
 }
 

diff --git a/crates/store/src/db/tests.rs b/crates/store/src/db/tests.rs
@@ -486,134 +486,6 @@ fn sql_public_account_details() {
     assert_eq!(read_delta, Some(delta2));
 }
 
-#[test]
-fn sql_select_nullifiers_by_block_range() {
-    let mut conn = create_db();
-
-    // test empty table
-    let nullifiers =
-        sql::select_nullifiers_by_block_range(&mut conn, 0.into(), u32::MAX.into(), &[]).unwrap();
-    assert!(nullifiers.is_empty());
-
-    // test single item
-    let nullifier1 = num_to_nullifier(1 << 48);
-    let block_number1 = 1.into();
-    create_block(&mut conn, block_number1);
-
-    let transaction = conn.transaction().unwrap();
-    sql::insert_nullifiers_for_block(&transaction, &[nullifier1], block_number1).unwrap();
-    transaction.commit().unwrap();
-
-    let nullifiers = sql::select_nullifiers_by_block_range(
-        &mut conn,
-        0.into(),
-        u32::MAX.into(),
-        &[sql::utils::get_nullifier_prefix(&nullifier1)],
-    )
-    .unwrap();
-    assert_eq!(
-        nullifiers,
-        vec![NullifierInfo {
-            nullifier: nullifier1,
-            block_num: block_number1
-        }]
-    );
-
-    // test two elements
-    let nullifier2 = num_to_nullifier(2 << 48);
-    let block_number2 = 2.into();
-    create_block(&mut conn, block_number2);
-
-    let transaction = conn.transaction().unwrap();
-    sql::insert_nullifiers_for_block(&transaction, &[nullifier2], block_number2).unwrap();
-    transaction.commit().unwrap();
-
-    let nullifiers = sql::select_all_nullifiers(&mut conn).unwrap();
-    assert_eq!(nullifiers, vec![(nullifier1, block_number1), (nullifier2, block_number2)]);
-
-    // only the nullifiers matching the prefix are included
-    let nullifiers = sql::select_nullifiers_by_block_range(
-        &mut conn,
-        0.into(),
-        u32::MAX.into(),
-        &[sql::utils::get_nullifier_prefix(&nullifier1)],
-    )
-    .unwrap();
-    assert_eq!(
-        nullifiers,
-        vec![NullifierInfo {
-            nullifier: nullifier1,
-            block_num: block_number1
-        }]
-    );
-    let nullifiers = sql::select_nullifiers_by_block_range(
-        &mut conn,
-        0.into(),
-        u32::MAX.into(),
-        &[sql::utils::get_nullifier_prefix(&nullifier2)],
-    )
-    .unwrap();
-    assert_eq!(
-        nullifiers,
-        vec![NullifierInfo {
-            nullifier: nullifier2,
-            block_num: block_number2
-        }]
-    );
-
-    // Nullifiers created at block_end are included
-    let nullifiers = sql::select_nullifiers_by_block_range(
-        &mut conn,
-        0.into(),
-        1.into(),
-        &[
-            sql::utils::get_nullifier_prefix(&nullifier1),
-            sql::utils::get_nullifier_prefix(&nullifier2),
-        ],
-    )
-    .unwrap();
-    assert_eq!(
-        nullifiers,
-        vec![NullifierInfo {
-            nullifier: nullifier1,
-            block_num: block_number1
-        }]
-    );
-
-    // Nullifiers created at block_start are not included
-    let nullifiers = sql::select_nullifiers_by_block_range(
-        &mut conn,
-        1.into(),
-        u32::MAX.into(),
-        &[
-            sql::utils::get_nullifier_prefix(&nullifier1),
-            sql::utils::get_nullifier_prefix(&nullifier2),
-        ],
-    )
-    .unwrap();
-    assert_eq!(
-        nullifiers,
-        vec![NullifierInfo {
-            nullifier: nullifier2,
-            block_num: block_number2
-        }]
-    );
-
-    // When block start and end are the same, no nullifiers should be returned. This case happens
-    // when the client requests a sync update, and it is already tracking the chain tip.
-    let nullifiers = sql::select_nullifiers_by_block_range(
-        &mut conn,
-        2.into(),
-        2.into(),
-        &[
-            sql::utils::get_nullifier_prefix(&nullifier1),
-            sql::utils::get_nullifier_prefix(&nullifier2),
-        ],
-    )
-    .unwrap();
-    assert!(nullifiers.is_empty());
-}
-
 #[test]
 fn select_nullifiers_by_prefix() {
     const PREFIX_LEN: u32 = 16;