accumulators 0.5.1

Complete package of multiple Accumulators with Stores and hashing functions (Hashers)
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
60
61
62
63
64
65
66

use thiserror::Error;
/// Formatting
#[derive(Clone)]
pub struct FormattingOptions {
    pub output_size: usize,
    pub null_value: String,
}

pub type ProofFormattingOptions = FormattingOptions;
pub type PeaksFormattingOptions = FormattingOptions;

// pub fn validate_formatting_options(options: &FormattingOptions) -> Result<(), String> {
//     if !options.null_value.starts_with("0x") {
//         return Err("Formatting options: nullValue must be a hex string".to_string());
//     }

//     if usize::from_str_radix(&options.null_value[2..], 16).is_err() {
//         return Err("Formatting options: nullValue must be a hex string".to_string());
//     }

//     Ok(())
// }

/// Formatting error
#[derive(Error, Debug)]
pub enum FormattingError {
    #[error("Formatting: Expected peaks output size is smaller than the actual size")]
    PeaksOutputSizeError,
    #[error("Formatting: Expected proof output size is smaller than the actual size")]
    ProofOutputSizeError,
}

pub fn format_peaks(
    mut peaks: Vec<String>,
    formatting_opts: &PeaksFormattingOptions,
) -> Result<Vec<String>, FormattingError> {
    if peaks.len() > formatting_opts.output_size {
        return Err(FormattingError::PeaksOutputSizeError);
    }

    let expected_peaks_size_remainder = formatting_opts.output_size - peaks.len();
    let peaks_null_values: Vec<String> =
        vec![formatting_opts.null_value.clone(); expected_peaks_size_remainder];

    peaks.extend(peaks_null_values);

    Ok(peaks)
}

pub fn format_proof(
    siblings_hashes: Vec<String>,
    formatting_opts: ProofFormattingOptions,
) -> Result<Vec<String>, FormattingError> {
    if siblings_hashes.len() > formatting_opts.output_size {
        return Err(FormattingError::ProofOutputSizeError);
    }

    let expected_proof_size_remainder = formatting_opts.output_size - siblings_hashes.len();
    let mut proof_null_values =
        vec![formatting_opts.null_value.clone(); expected_proof_size_remainder];

    let mut result = siblings_hashes;
    result.append(&mut proof_null_values);

    Ok(result)
}