Added some more fuzzers in to the source

fuzz/Cargo.toml

@@ -16,9 +16,13 @@ workspace = true
 [dependencies]
 afl = { version = "0.15.11", optional = true }
 
+nimiq-account = { workspace = true }
+nimiq-bls = { workspace = true }
 nimiq-collections = { workspace = true }
+nimiq-keys = { workspace = true }
 nimiq-primitives = { workspace = true, features = ["key-nibbles", "serde-derive", "trie"] }
 nimiq-serde = { workspace = true }
+nimiq-transaction = { workspace = true }
 
 [features]
 fuzz = ["afl"]

fuzz/src/bin/bitset.rs

@@ -3,7 +3,6 @@ fn main() {
     afl::fuzz!(|data: &[u8]| {
         use nimiq_collections::BitSet;
         use nimiq_serde::Deserialize as _;
-
         let _ = BitSet::deserialize_from_vec(data);
     })
 }

fuzz/src/bin/coin.rs

@@ -0,0 +1,8 @@
+fn main() {
+    #[cfg(feature = "fuzz")]
+    afl::fuzz!(|data: &[u8]| {
+        use nimiq_serde::Deserialize as _;
+        use nimiq_primitives::coin::Coin;
+        let _ = Coin::deserialize_from_vec(data);
+    })
+}

fuzz/src/bin/htlc.rs

@@ -0,0 +1,10 @@
+fn main() {
+    #[cfg(feature = "fuzz")]
+    afl::fuzz!(|data: &[u8]| {
+        use nimiq_serde::Deserialize as _;
+        use nimiq_account::{
+            HashedTimeLockedContract
+        }; 
+        let _ = HashedTimeLockedContract::deserialize_from_vec(data);
+    })
+}

fuzz/src/bin/key_nibbles.rs

@@ -3,7 +3,6 @@ fn main() {
     afl::fuzz!(|data: &[u8]| {
         use nimiq_primitives::key_nibbles::KeyNibbles;
         use nimiq_serde::Deserialize as _;
-
         let _ = KeyNibbles::deserialize_from_vec(data);
     })
 }

fuzz/src/bin/keypair.rs

@@ -0,0 +1,8 @@
+fn main() {
+    #[cfg(feature = "fuzz")]
+    afl::fuzz!(|data: &[u8]| {
+        use nimiq_serde::Deserialize as _;
+        use nimiq_bls::{KeyPair};
+        let _ = KeyPair::deserialize_from_vec(data);
+    })
+}

fuzz/src/bin/normal_keypair.rs

@@ -0,0 +1,8 @@
+fn main() {
+    #[cfg(feature = "fuzz")]
+    afl::fuzz!(|data: &[u8]| {
+        use nimiq_serde::Deserialize as _;
+        use nimiq_keys::KeyPair;
+        let _ = KeyPair::deserialize_from_vec(data);
+    })
+}

fuzz/src/bin/staking_contract.rs

@@ -0,0 +1,21 @@
+fn main() { 
+    #[cfg(feature = "fuzz")]
+    afl::fuzz!(|data: &[u8]| {
+        use nimiq_serde::{Deserialize, Serialize};
+        use nimiq_account::StakingContract;
+        let res = StakingContract::deserialize_from_vec(data); // err I think is of type DeserializeError
+        // Now check if contract exists. If it does (aka. the original data was a valid staking contract) then try to serialize it back to a vector, then check if the original vector and the new vector are the same, if they aren't then there is a bug in the parsing logic.
+        // The existence of error implies that contract does not exist.
+        match res {
+            Ok(v) => {
+                let serialized = StakingContract::serialize_to_vec(&v);
+                assert!((serialized.len() <= data.len()), "The size of the serialized version was bigger than the original vector! This shouldn't happen!");
+                let original_data_segment: &[u8] = data[..(serialized.len())].try_into().unwrap(); // This ugly stuff has to be done, because the serialization function ignores extra bytes at the end so we can not compare the byte vectors by themselves. Yuck!!!
+                assert_eq!(original_data_segment, serialized);
+            },
+            Err(e) => {
+                return;
+            },
+        }
+    })
+}

fuzz/src/bin/transaction.rs

@@ -0,0 +1,8 @@
+fn main() {
+    #[cfg(feature = "fuzz")]
+    afl::fuzz!(|data: &[u8]| {
+        use nimiq_serde::Deserialize as _;
+        use nimiq_transaction::{Transaction};
+        let _ = Transaction::deserialize_from_vec(data);
+    })
+}

fuzz/src/bin/trie_node.rs

@@ -3,7 +3,6 @@ fn main() {
     afl::fuzz!(|data: &[u8]| {
         use nimiq_primitives::trie::trie_node::TrieNode;
         use nimiq_serde::Deserialize as _;
-
         let _ = TrieNode::deserialize_from_vec(data);
     })
 }