[cryptography/bloomfilter] generic Hasher and optimizations

cryptography/Cargo.toml

@@ -127,3 +127,8 @@ path = "src/lthash/benches/bench.rs"
 name = "handshake"
 harness = false
 path = "src/handshake/benches/bench.rs"
+
+[[bench]]
+name = "bloomfilter"
+harness = false
+path = "src/bloomfilter/benches/bench.rs"

cryptography/conformance.toml

@@ -2,9 +2,13 @@
 n_cases = 65536
 hash = "c0501d4a691d1fccec7c5906e8608228569d24164150edd215838593e3b77512"
 
-["commonware_cryptography::bloomfilter::tests::conformance::CodecConformance<BloomFilter>"]
+["commonware_cryptography::bloomfilter::conformance::CodecConformance<BloomFilter>"]
 n_cases = 65536
-hash = "a75d6312366816126114abdc9d7fbd246891cab210eeae6a02781625aa1ad6a4"
+hash = "698dac6cf35fcd1557a962e7215da4251d7e42f68a2331b70ff0dd542c4116dd"
+
+["commonware_cryptography::bloomfilter::conformance::FpRateBuckets"]
+n_cases = 1024
+hash = "723f3a5fd8b147f722d5fa990f39b3ffd6a2f0df46d00dcb1e294647b565eb85"
 
 ["commonware_cryptography::bls12381::certificate::multisig::tests::conformance::CodecConformance<Certificate<MinSig>>"]
 n_cases = 65536

cryptography/fuzz/fuzz_targets/bloomfilter.rs

@@ -2,11 +2,11 @@
 
 use arbitrary::Arbitrary;
 use commonware_codec::{Decode, Encode, EncodeSize};
-use commonware_cryptography::BloomFilter;
+use commonware_cryptography::{sha256::Sha256, BloomFilter};
 use libfuzzer_sys::fuzz_target;
 use std::{
     collections::HashSet,
-    num::{NonZeroU16, NonZeroU8},
+    num::{NonZeroU16, NonZeroU8, NonZeroUsize},
 };
 
 #[derive(Arbitrary, Debug)]
@@ -18,30 +18,73 @@ enum Op {
     EncodeSize,
 }
 
+#[derive(Debug)]
+enum Constructor {
+    New {
+        hashers: NonZeroU8,
+        bits: NonZeroU16,
+    },
+    WithRate {
+        expected_items: NonZeroU16,
+        fp_rate: f64,
+    },
+}
+
+impl<'a> Arbitrary<'a> for Constructor {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        if u.arbitrary::<bool>()? {
+            let hashers = u.arbitrary()?;
+            // Fallback to highest power of two in u16 on overflow
+            let bits = u
+                .arbitrary::<u16>()?
+                .checked_next_power_of_two()
+                .and_then(NonZeroU16::new)
+                .unwrap_or(NonZeroU16::new(1 << 15).unwrap());
+            Ok(Constructor::New { hashers, bits })
+        } else {
+            let expected_items = u.arbitrary::<NonZeroU16>()?;
+            // Generate f64 in range (0.0, 1.0) exclusive
+            let fp_rate = u.int_in_range(1u32..=u32::MAX - 1)? as f64 / u32::MAX as f64;
+            Ok(Constructor::WithRate {
+                expected_items,
+                fp_rate,
+            })
+        }
+    }
+}
+
 const MAX_OPERATIONS: usize = 64;
 
 #[derive(Debug)]
 struct FuzzInput {
-    hashers: NonZeroU8,
-    bits: NonZeroU16,
+    constructor: Constructor,
     ops: Vec<Op>,
 }
 
 impl<'a> Arbitrary<'a> for FuzzInput {
     fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-        let hashers = u.arbitrary()?;
-        let bits = u.arbitrary()?;
+        let constructor = u.arbitrary()?;
         let num_ops = u.int_in_range(1..=MAX_OPERATIONS)?;
         let ops = (0..num_ops)
             .map(|_| Op::arbitrary(u))
             .collect::<Result<Vec<_>, _>>()?;
-        Ok(FuzzInput { hashers, bits, ops })
+        Ok(FuzzInput { constructor, ops })
     }
 }
 
 fn fuzz(input: FuzzInput) {
-    let cfg = (input.hashers, input.bits.into());
-    let mut bf = BloomFilter::new(input.hashers, input.bits.into());
+    let mut bf = match input.constructor {
+        Constructor::New { hashers, bits } => BloomFilter::<Sha256>::new(hashers, bits.into()),
+        Constructor::WithRate {
+            expected_items,
+            fp_rate,
+        } => BloomFilter::<Sha256>::with_rate(
+            NonZeroUsize::new(expected_items.get() as usize).unwrap(),
+            fp_rate,
+        ),
+    };
+
+    let cfg = (bf.hashers(), bf.bits().try_into().unwrap());
     let mut model: HashSet<Vec<u8>> = HashSet::new();
 
     for op in input.ops {
@@ -58,11 +101,11 @@ fn fuzz(input: FuzzInput) {
             }
             Op::DecodeCfg(data, hashers, bits) => {
                 let cfg = (hashers, bits.into());
-                _ = BloomFilter::decode_cfg(&data[..], &cfg);
+                _ = BloomFilter::<Sha256>::decode_cfg(&data[..], &cfg);
             }
             Op::Encode(_item) => {
                 let encoded = bf.encode();
-                let decoded = BloomFilter::decode_cfg(encoded.clone(), &cfg).unwrap();
+                let decoded = BloomFilter::<Sha256>::decode_cfg(encoded.clone(), &cfg).unwrap();
                 assert_eq!(bf, decoded);
 
                 let encode_size = bf.encode_size();
@@ -80,7 +123,7 @@ fn fuzz(input: FuzzInput) {
                     "encode_size should match encode().len()"
                 );
 
-                let decoded = BloomFilter::decode_cfg(encoded, &cfg).unwrap();
+                let decoded = BloomFilter::<Sha256>::decode_cfg(encoded, &cfg).unwrap();
                 assert_eq!(bf, decoded);
 
                 assert_eq!(decoded.encode_size(), size1);