add other operations

Author: armaganyildirak

fuzz/fuzz_targets/standard/fuzz_database_states.rs

@@ -6,7 +6,7 @@ use database::NetworkDatabase;
 use indexmap::IndexSet;
 use openssl::rsa::Rsa;
 use ssv_types::{
-    Cluster, ClusterId, OperatorId, Share, ValidatorIndex, ValidatorMetadata, ENCRYPTED_KEY_LENGTH,
+    Cluster, ClusterId, Operator, OperatorId, Share, ValidatorIndex, ValidatorMetadata, ENCRYPTED_KEY_LENGTH,
 };
 use ssz::Decode;
 use std::{path::Path, sync::OnceLock};
@@ -46,24 +46,51 @@ static RSA_KEY: OnceLock<Rsa<openssl::pkey::Public>> = OnceLock::new();
 
 #[derive(Arbitrary, Debug)]
 enum DbAction {
-    InsertValidator,
-    UpdateStatus(bool),
-    DeleteValidator,
-    BumpNonce,
+    InsertValidator {
+        cluster_id: [u8; 32],
+        owner: [u8; 20],
+        fee_recipient: [u8; 20],
+        liquidated: bool,
+        validator_pubkey: [u8; 48],
+        share_pubkey: [u8; 48],
+        operator_id: u64,
+        encrypted_private_key: [u8; ENCRYPTED_KEY_LENGTH],
+        validator_index: usize,
+        graffiti: [u8; 32],
+    },
+    UpdateStatus {
+        cluster_id: [u8; 32],
+        status: bool,
+    },
+    DeleteValidator {
+        validator_pubkey: [u8; 48],
+    },
+    BumpNonce {
+        owner: [u8; 20],
+    },
+    InsertOperator {
+        operator_id: u64,
+        owner: [u8; 20],
+    },
+    DeleteOperator {
+        operator_id: u64,
+    },
+    UpdateFeeRecipient {
+        owner: [u8; 20],
+        fee_recipient: [u8; 20],
+    },
+    UpdateGraffiti {
+        validator_pubkey: [u8; 48],
+        graffiti: [u8; 32],
+    },
+    SetValidatorIndices {
+        validator_pubkey: [u8; 48],
+        index: Option<usize>,
+    },
 }
 
 #[derive(Arbitrary, Debug)]
 struct FuzzData {
-    cluster_id: [u8; 32],
-    owner: [u8; 20],
-    fee_recipient: [u8; 20],
-    liquidated: bool,
-    validator_pubkey: [u8; 48],
-    share_pubkey: [u8; 48],
-    operator_id: u64,
-    encrypted_private_key: [u8; ENCRYPTED_KEY_LENGTH],
-    validator_index: usize,
-    graffiti: [u8; 32],
     actions: Vec<DbAction>,
 }
 
@@ -92,40 +119,6 @@ fn fuzz_with_data(fuzz: FuzzData) {
         return;
     };
 
-    // Create test data with correct types
-    let mut cluster_members = IndexSet::new();
-    cluster_members.insert(OperatorId(fuzz.operator_id));
-
-    let Ok(validator_pk) = PublicKeyBytes::from_ssz_bytes(&fuzz.validator_pubkey) else {
-        return;
-    };
-    let Ok(share_pk) = PublicKeyBytes::from_ssz_bytes(&fuzz.share_pubkey) else {
-        return;
-    };
-
-    let cluster = Cluster {
-        cluster_id: ClusterId(fuzz.cluster_id),
-        owner: Address::from(fuzz.owner),
-        fee_recipient: Address::from(fuzz.fee_recipient),
-        liquidated: fuzz.liquidated,
-        cluster_members,
-    };
-
-    let validator = ValidatorMetadata {
-        public_key: validator_pk,
-        cluster_id: ClusterId(fuzz.cluster_id),
-        index: Some(ValidatorIndex(fuzz.validator_index)),
-        graffiti: Graffiti(fuzz.graffiti),
-    };
-
-    let share = Share {
-        validator_pubkey: validator_pk,
-        operator_id: OperatorId(fuzz.operator_id),
-        cluster_id: ClusterId(fuzz.cluster_id),
-        share_pubkey: share_pk,
-        encrypted_private_key: fuzz.encrypted_private_key,
-    };
-
     for action in fuzz.actions {
         let Ok(conn) = old.connection() else {
             return;
@@ -135,17 +128,94 @@ fn fuzz_with_data(fuzz: FuzzData) {
         };
 
         match action {
-            DbAction::InsertValidator => {
-                let _ = old.insert_validator(cluster.clone(), &validator, vec![share.clone()], &tx);
+            DbAction::InsertValidator { 
+                cluster_id,
+                owner,
+                fee_recipient,
+                liquidated,
+                validator_pubkey,
+                share_pubkey,
+                operator_id,
+                encrypted_private_key,
+                validator_index,
+                graffiti,
+            } => {
+                let Ok(validator_pk) = PublicKeyBytes::from_ssz_bytes(&validator_pubkey) else {
+                    continue;
+                };
+                let Ok(share_pk) = PublicKeyBytes::from_ssz_bytes(&share_pubkey) else {
+                    continue;
+                };
+
+                let mut cluster_members = IndexSet::new();
+                cluster_members.insert(OperatorId(operator_id));
+
+                let cluster = Cluster {
+                    cluster_id: ClusterId(cluster_id),
+                    owner: Address::from(owner),
+                    fee_recipient: Address::from(fee_recipient),
+                    liquidated,
+                    cluster_members,
+                };
+
+                let validator = ValidatorMetadata {
+                    public_key: validator_pk,
+                    cluster_id: ClusterId(cluster_id),
+                    index: Some(ValidatorIndex(validator_index)),
+                    graffiti: Graffiti(graffiti),
+                };
+
+                let share = Share {
+                    validator_pubkey: validator_pk,
+                    operator_id: OperatorId(operator_id),
+                    cluster_id: ClusterId(cluster_id),
+                    share_pubkey: share_pk,
+                    encrypted_private_key,
+                };
+
+                let _ = old.insert_validator(cluster, &validator, vec![share], &tx);
+            }
+            DbAction::UpdateStatus { cluster_id, status } => {
+                let _ = old.update_status(ClusterId(cluster_id), status, &tx);
             }
-            DbAction::UpdateStatus(status) => {
-                let _ = old.update_status(ClusterId(fuzz.cluster_id), status, &tx);
+            DbAction::DeleteValidator { validator_pubkey } => {
+                let Ok(validator_pk) = PublicKeyBytes::from_ssz_bytes(&validator_pubkey) else {
+                    continue;
+                };
+                let _ = old.delete_validator(&validator_pk, &tx);
             }
-            DbAction::DeleteValidator => {
-                let _ = old.delete_validator(&validator.public_key, &tx);
+            DbAction::BumpNonce { owner } => {
+                let _ = old.bump_and_get_nonce(&Address::from(owner), &tx);
             }
-            DbAction::BumpNonce => {
-                let _ = old.bump_and_get_nonce(&cluster.owner, &tx);
+            DbAction::InsertOperator { operator_id, owner } => {
+                let operator = Operator {
+                        id: OperatorId(operator_id),
+                        rsa_pubkey: rsa_key.clone(),
+                        owner: Address::from(owner),
+                };
+                let _ = old.insert_operator(&operator, &tx);
+            }
+            DbAction::DeleteOperator { operator_id } => {
+                let _ = old.delete_operator(OperatorId(operator_id), &tx);
+            }
+            DbAction::UpdateFeeRecipient { owner, fee_recipient } => {
+                let _ = old.update_fee_recipient(Address::from(owner), Address::from(fee_recipient), &tx);
+            }
+            DbAction::UpdateGraffiti { validator_pubkey, graffiti } => {
+                if let Ok(validator_pk) = PublicKeyBytes::from_ssz_bytes(&validator_pubkey) {
+                    let _ = old.update_graffiti(&validator_pk, Graffiti(graffiti), &tx);
+                };
+            }
+            DbAction::SetValidatorIndices { validator_pubkey, index } => {
+                if let Ok(validator_pk) = PublicKeyBytes::from_ssz_bytes(&validator_pubkey) {
+                    if let Some(idx) = index {
+                        let mut map = std::collections::HashMap::new();
+                        map.insert(validator_pk, ValidatorIndex(idx));
+                        let _ = old.set_validator_indices(map);
+                        continue;
+                    };
+                };
+
             }
         }
 
@@ -186,4 +256,4 @@ fn main() {
         };
         fuzz_with_data(fuzz);
     });
-}
+}