commonware-storage 2026.10.0

Persist and retrieve data from an abstract store.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::common::{N_LEAVES, SAMPLE_SIZE, StandardHasher, range_samples};
use commonware_cryptography::Sha256;
use commonware_storage::merkle::{Bagging::ForwardFold, Family};
use criterion::{BatchSize, Criterion, criterion_group};
use futures::executor::block_on;

/// Times range proof verification, with the proofs generated in setup.
fn bench_verify_many_elements_family<F: Family>(c: &mut Criterion, family: &str) {
    for n in N_LEAVES {
        for range in [2, 5, 10, 25, 50, 100, 250, 500, 1_000, 5_000] {
            c.bench_function(
                &format!(
                    "{}/n={n} range={range} samples={SAMPLE_SIZE} family={family}",
                    module_path!(),
                ),
                |b| {
                    b.iter_batched(
                        || {
                            let (mem, root, samples) = range_samples::<F>(n, range);
                            let hasher = StandardHasher::<Sha256>::new(ForwardFold);
                            let proofs = block_on(async {
                                let mut proofs = Vec::with_capacity(samples.len());
                                for (range, elements) in samples {
                                    let proof = mem.range_proof(&hasher, range.clone(), 0).unwrap();
                                    proofs.push((range, elements, proof));
                                }
                                proofs
                            });
                            (root, proofs)
                        },
                        |(root, proofs)| {
                            let hasher = StandardHasher::<Sha256>::new(ForwardFold);
                            for (range, elements, proof) in proofs {
                                assert!(proof.verify_range_inclusion(
                                    &hasher,
                                    &elements,
                                    range.start,
                                    &root
                                ));
                            }
                        },
                        BatchSize::LargeInput,
                    )
                },
            );
        }
    }
}

fn bench_verify_many_elements(c: &mut Criterion) {
    bench_verify_many_elements_family::<commonware_storage::mmr::Family>(c, "mmr");
    bench_verify_many_elements_family::<commonware_storage::mmb::Family>(c, "mmb");
}

criterion_group! {
    name = benches;
    config = Criterion::default().sample_size(10);
    targets = bench_verify_many_elements
}