Merge branch 'unstable' into revert-base-hash

Author: dknopik

Cargo.lock

@@ -6,7 +6,6 @@ authors = ["Sigma Prime <[email protected]>"]
 
 [dependencies]
 base64 = { workspace = true }
-multi_index_map = "0.15.0"
 once_cell = { workspace = true }
 openssl = { workspace = true }
 r2d2 = { workspace = true }

anchor/database/Cargo.toml

@@ -2,9 +2,7 @@ use rusqlite::{Transaction, params};
 use ssv_types::{Cluster, ClusterId, OperatorId, Share, ValidatorMetadata};
 use types::{Address, PublicKeyBytes};
 
-use super::{
-    ClusterIndexed, DatabaseError, MetadataIndexed, NetworkDatabase, ShareIndexed, sql_operations,
-};
+use super::{DatabaseError, NetworkDatabase, NonUniqueIndex, UniqueIndex, sql_operations};
 
 /// Implements all cluster related functionality on the database
 impl NetworkDatabase {
@@ -60,43 +58,33 @@ impl NetworkDatabase {
                 // Record that we are a member of this cluster
                 state.single_state.clusters.insert(cluster.cluster_id);
 
-                state.multi_state.shares.insert(ShareIndexed {
-                    validator_pubkey: validator.public_key,
-                    cluster_id: cluster.cluster_id,
-                    owner: cluster.owner,
-                    committee_id: cluster.committee_id(),
-                    share: share.to_owned(),
-                });
+                // Save the keyshare
+                state.multi_state.shares.insert_or_update(
+                    &validator.public_key,   // The validator this keyshare belongs to
+                    &cluster.cluster_id,     // The id of the cluster
+                    &cluster.owner,          // The owner of the cluster
+                    &cluster.committee_id(), // The committee id of the cluster
+                    share.to_owned(),        // The keyshare itself
+                );
             }
 
             // Save all cluster related information
-            // Check if we already have this cluster
-            let existing = state
-                .multi_state
-                .clusters
-                .get_by_cluster_id(&cluster.cluster_id)
-                .is_some();
-
-            // Only insert if it doesn't exist yet
-            if !existing {
-                state.multi_state.clusters.insert(ClusterIndexed {
-                    cluster_id: cluster.cluster_id,
-                    owner: cluster.owner,
-                    committee_id: cluster.committee_id(),
-                    cluster: cluster.to_owned(),
-                });
-            }
-
-            state
-                .multi_state
-                .validator_metadata
-                .insert(MetadataIndexed {
-                    validator_pubkey: validator.public_key,
-                    cluster_id: cluster.cluster_id,
-                    owner: cluster.owner,
-                    committee_id: cluster.committee_id(),
-                    metadata: validator.to_owned(),
-                });
+            state.multi_state.clusters.insert_or_update(
+                &cluster.cluster_id,     // The id of the cluster
+                &validator.public_key,   // The public key of validator added to the cluster
+                &cluster.owner,          // Owner of the cluster
+                &cluster.committee_id(), // The committee id of the cluster
+                cluster.to_owned(),      // The Cluster and all containing information
+            );
+
+            // Save the metadata for the validators
+            state.multi_state.validator_metadata.insert_or_update(
+                &validator.public_key,   // The public key of the validator
+                &cluster.cluster_id,     // The id of the cluster the validator belongs to
+                &cluster.owner,          // The owner of the cluster
+                &cluster.committee_id(), // The committee id of the cluster
+                validator.to_owned(),    // The metadata of the validator
+            );
         });
 
         Ok(())
@@ -117,12 +105,9 @@ impl NetworkDatabase {
 
         // Update in memory status of cluster
         self.modify_state(|state| {
-            state
-                .multi_state
-                .clusters
-                .modify_by_cluster_id(&cluster_id, |cluster_idx| {
-                    cluster_idx.cluster.liquidated = status;
-                });
+            if let Some(cluster) = state.multi_state.clusters.get_mut_by(&cluster_id) {
+                cluster.liquidated = status;
+            }
         });
 
         Ok(())
@@ -142,33 +127,24 @@ impl NetworkDatabase {
 
         self.modify_state(|state| {
             // Remove from in memory
-            state
-                .multi_state
-                .shares
-                .remove_by_validator_pubkey(validator_pubkey);
-
-            let metadata_idx = state
+            state.multi_state.shares.remove(validator_pubkey);
+            let metadata = state
                 .multi_state
                 .validator_metadata
-                .remove_by_validator_pubkey(validator_pubkey)
+                .remove(validator_pubkey)
                 .expect("Data should have existed");
 
             // If there is no longer and validators for this cluster, remove it from both the
             // cluster multi index map and the cluster membership set
             if state
                 .multi_state
                 .validator_metadata
-                .get_by_cluster_id(&metadata_idx.metadata.cluster_id)
-                .is_empty()
+                .get_all_by(&metadata.cluster_id)
+                .next()
+                .is_none()
             {
-                state
-                    .multi_state
-                    .clusters
-                    .remove_by_cluster_id(&metadata_idx.metadata.cluster_id);
-                state
-                    .single_state
-                    .clusters
-                    .remove(&metadata_idx.metadata.cluster_id);
+                state.multi_state.clusters.remove(&metadata.cluster_id);
+                state.single_state.clusters.remove(&metadata.cluster_id);
             }
         });
 

anchor/database/src/cluster_operations.rs

@@ -4,7 +4,6 @@ use std::{
     time::Duration,
 };
 
-use multi_index_map::MultiIndexMap;
 use once_cell::sync::OnceCell;
 use openssl::{pkey::Public, rsa::Rsa};
 use r2d2_sqlite::SqliteConnectionManager;
@@ -19,64 +18,16 @@ use tokio::sync::{
 };
 use types::{Address, PublicKeyBytes};
 
-pub use crate::{error::DatabaseError, state::NetworkState};
-
-/// All the shares that belong to the current operator.
-/// IMPORTANT: There are parts of the code that assume this only contains shares that belong to the
-/// current operator. If this ever changes, make sure to update the code accordingly.
-#[derive(Debug, Clone, MultiIndexMap)]
-pub struct ShareIndexed {
-    #[multi_index(hashed_unique)]
-    pub validator_pubkey: PublicKeyBytes,
-
-    #[multi_index(hashed_non_unique)]
-    pub cluster_id: ClusterId,
-
-    #[multi_index(hashed_non_unique)]
-    pub owner: Address,
-
-    #[multi_index(hashed_non_unique)]
-    pub committee_id: CommitteeId,
-
-    pub share: Share,
-}
-
-/// Metadata for all validators in the network
-#[derive(Debug, Clone, MultiIndexMap)]
-pub struct MetadataIndexed {
-    #[multi_index(hashed_unique)]
-    pub validator_pubkey: PublicKeyBytes,
-
-    #[multi_index(hashed_non_unique)]
-    pub cluster_id: ClusterId,
-
-    #[multi_index(hashed_non_unique)]
-    pub owner: Address,
-
-    #[multi_index(hashed_non_unique)]
-    pub committee_id: CommitteeId,
-
-    pub metadata: ValidatorMetadata,
-}
-
-/// All the clusters in the network
-#[derive(Debug, Clone, MultiIndexMap)]
-pub struct ClusterIndexed {
-    #[multi_index(hashed_unique)]
-    pub cluster_id: ClusterId,
-
-    #[multi_index(hashed_non_unique)]
-    pub owner: Address,
-
-    #[multi_index(hashed_non_unique)]
-    pub committee_id: CommitteeId,
-
-    pub cluster: Cluster,
-}
+pub use crate::{
+    error::DatabaseError,
+    multi_index::{MultiIndexMap, *},
+    state::NetworkState,
+};
 
 mod cluster_operations;
 mod error;
 mod keysplit_operations;
+mod multi_index;
 mod operator_operations;
 mod schema;
 mod share_operations;
@@ -93,16 +44,57 @@ const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
 type Pool = r2d2::Pool<SqliteConnectionManager>;
 type PoolConn = r2d2::PooledConnection<SqliteConnectionManager>;
 
-// The actual map types are generated by the macro and are named:
-// - MultiIndexShareIndexedMap
-// - MultiIndexMetadataIndexedMap
-// - MultiIndexClusterIndexedMap
-//
-// Information that needs to be accessed via multiple different indices
+/// All the shares that belong to the current operator.
+/// IMPORTANT: There are parts of the code that assume this only contains shares that belong to the
+/// current operator. If this ever changes, make sure to update the code accordingly.
+/// Primary: public key of validator, uniquely identifies a share
+/// Secondary: cluster id, corresponds to a list of shares
+/// Tertiary: owner of the cluster, corresponds to a list of shares
+pub type ShareMultiIndexMap = MultiIndexMap<
+    PublicKeyBytes,
+    ClusterId,
+    Address,
+    CommitteeId,
+    Share,
+    NonUniqueTag,
+    NonUniqueTag,
+    NonUniqueTag,
+>;
+/// Metadata for all validators in the network
+/// Primary: public key of the validator. uniquely identifies the metadata
+/// Secondary: cluster id. corresponds to list of metadata for all validators
+/// Tertiary: owner of the cluster: corresponds to list of metadata for all validators
+pub type MetadataMultiIndexMap = MultiIndexMap<
+    PublicKeyBytes,
+    ClusterId,
+    Address,
+    CommitteeId,
+    ValidatorMetadata,
+    NonUniqueTag,
+    NonUniqueTag,
+    NonUniqueTag,
+>;
+/// All of the clusters in the network
+/// Primary: cluster id. uniquely identifies a cluster
+/// Secondary: public key of the validator. uniquely identifies a cluster
+/// Tertiary: owner of the cluster. does not uniquely identify a cluster
+pub type ClusterMultiIndexMap = MultiIndexMap<
+    ClusterId,
+    PublicKeyBytes,
+    Address,
+    CommitteeId,
+    Cluster,
+    UniqueTag,
+    NonUniqueTag,
+    NonUniqueTag,
+>;
+
+// Information that needs to be accessed via multiple different indicies
+#[derive(Debug)]
 struct MultiState {
-    shares: MultiIndexShareIndexedMap,
-    validator_metadata: MultiIndexMetadataIndexedMap,
-    clusters: MultiIndexClusterIndexedMap,
+    shares: ShareMultiIndexMap,
+    validator_metadata: MetadataMultiIndexMap,
+    clusters: ClusterMultiIndexMap,
     // Be careful when adding new maps here. If you really must to, it must be updated in the
     // operations files
 }
@@ -132,6 +124,7 @@ enum PubkeyOrId {
 
 /// Top level NetworkDatabase that contains in memory storage for quick access
 /// to relevant information and a connection to the database
+#[derive(Debug)]
 pub struct NetworkDatabase {
     /// The public key or ID of our operator
     operator: PubkeyOrId,