try some fuzzing?

no joy

Cargo.lock

···
 checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
 
 [[package]]
+name = "arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+
+[[package]]
 name = "arrayvec"
 version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
 
 [[package]]
+name = "libfuzzer-sys"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf78f52d400cf2d84a3a973a78a592b4adc535739e0a5597a0da6f0c357adc75"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
+[[package]]
 name = "libloading"
 version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "errno",
  "libc",
  "linux-raw-sys 0.9.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "getrandom 0.3.2",
  "once_cell",
  "rustix 1.0.5",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "thiserror 2.0.12",
  "tikv-jemallocator",
  "tokio",
+]
+
+[[package]]
+name = "ufos-fuzz"
+version = "0.0.0"
+dependencies = [
+ "jetstream",
+ "libfuzzer-sys",
+ "ufos",
 ]
 
 [[package]]

Cargo.toml

···
     "constellation",
     "jetstream",
     "ufos",
+    "ufos/fuzz",
 ]

ufos/fuzz/.gitignore

···
+target
+corpus
+artifacts
+coverage

ufos/fuzz/Cargo.toml

···
+[package]
+name = "ufos-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.ufos]
+path = ".."
+
+[dependencies.jetstream]
+path = "../../jetstream"
+
+[[bin]]
+name = "counts_value"
+path = "fuzz_targets/counts_value.rs"
+test = false
+doc = false
+bench = false

ufos/fuzz/fuzz_targets/counts_value.rs

···
+#![no_main]
+
+// use jetstream::exports::Did;
+use ufos::db_types::DbBytes;
+use ufos::store_types::CountsValue;
+use libfuzzer_sys::fuzz_target;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok((counts_value, n)) = CountsValue::from_db_bytes(data) {
+        assert!(n <= data.len());
+        let serialized = counts_value.to_db_bytes().unwrap();
+        assert_eq!(serialized.len(), n);
+        let (and_back, n_again) = CountsValue::from_db_bytes(&serialized).unwrap();
+        assert_eq!(n_again, n);
+        assert_eq!(and_back.records(), counts_value.records());
+        assert_eq!(and_back.dids().estimate(), counts_value.dids().estimate());
+        // assert_eq!(serialized, data[..n]);
+        // counts_value.prefix.0 += 1;
+        // counts_value.suffix.0.insert(&Did::new("did:plc:blah".to_string()).unwrap());
+        // assert!(counts_value.records() > 0);
+        // assert!(counts_value.dids().estimate() > 0);
+    }
+});

ufos/src/db_types.rs

···
         Self: Sized,
     {
         let (prefix, eaten) = P::from_db_bytes(bytes)?;
+        assert!(eaten <= bytes.len(), "eaten({}) < len({})", eaten, bytes.len());
         let Some(suffix_bytes) = bytes.get(eaten..) else {
             return Err(EncodingError::DecodeMissingSuffix);
         };
+        if suffix_bytes.len() == 0 {
+            return Err(EncodingError::DecodeMissingSuffix);
+        };
         let (suffix, also_eaten) = S::from_db_bytes(suffix_bytes)?;
+        assert!(also_eaten <= suffix_bytes.len(), "also eaten({}) < suffix len({})", also_eaten, suffix_bytes.len());
         Ok((Self { prefix, suffix }, eaten + also_eaten))
     }
 }

ufos/src/store_types.rs

···
 impl SerdeBytes for EstimatedDidsValue {}
 impl DbBytes for EstimatedDidsValue {
     fn to_db_bytes(&self) -> Result<Vec<u8>, EncodingError> {
-        Ok(vec![1, 2, 3])
-        // SerdeBytes::to_bytes(self)
+        // Ok(vec![1, 2, 3])
+        SerdeBytes::to_bytes(self)
     }
-    fn from_db_bytes(_bytes: &[u8]) -> Result<(Self, usize), EncodingError> {
-        Ok((Self(CardinalityEstimator::new()), 3))
-        // SerdeBytes::from_bytes(bytes)
+    fn from_db_bytes(bytes: &[u8]) -> Result<(Self, usize), EncodingError> {
+        // Ok((Self(CardinalityEstimator::new()), 3))
+        SerdeBytes::from_bytes(bytes)
     }
 }