smtree 0.1.2

SMTree is a flexible sparse tree accumulator that can support various tree types via traits for custom node-merging (i.e., Merkle tree hashes) and tree-padding logic. The api supports single and batch inclusion proofs and random sampling.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Copyright (c) Facebook, Inc. and its affiliates.
//
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.

//! This module provides definitions of errors might be returned by this library.

use crate::index::MAX_HEIGHT;

/// Errors occur during deserialization.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DecodingError {
    /// Decoded tree height or index height exceeds [MAX_HEIGHT]
    ExceedMaxHeight,
    /// Provided index does not fit to the tree
    IndexOverflow,
    /// There are more bytes than required for deserialization.
    TooManyEncodedBytes,
    /// Bytes are not enough for deserialization.
    BytesNotEnough,
    /// Error when decoding customized data type.
    ValueDecodingError {
        /// ```msg``` is the error message.
        msg: String,
    },
}

impl core::fmt::Display for DecodingError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            DecodingError::ExceedMaxHeight => {
                write!(
                    f,
                    "The height exceeds the maximum height, {}, in an SMT.",
                    MAX_HEIGHT
                )?;
            }
            DecodingError::IndexOverflow => {
                write!(f, "Index Overflow")?;
            }
            DecodingError::TooManyEncodedBytes => {
                write!(f, "Too many encoded bytes than required")?;
            }
            DecodingError::BytesNotEnough => {
                write!(f, "Bytes are not enough for decoding.")?;
            }
            DecodingError::ValueDecodingError { msg } => {
                write!(f, "Value decoding error: {}", msg)?;
            }
        }
        Ok(())
    }
}

impl std::error::Error for DecodingError {}

/// Errors occur when operating on the SMT.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TreeError {
    /// Error when the index of input leaf node doesn't match with that of the tree.
    HeightNotMatch,
    /// Error when the indexes are not sorted.
    IndexNotSorted,
    /// Error when there are duplicated indexes in the list.
    IndexDuplicated,
    /// Errors related to SMTree Secret.
    SecretError,
}

impl core::fmt::Display for TreeError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            TreeError::HeightNotMatch => {
                write!(
                    f,
                    "The height of the index doesn't match with the height of the tree."
                )?;
            }
            TreeError::IndexNotSorted => {
                write!(f, "The indexes are not sorted.")?;
            }
            TreeError::IndexDuplicated => {
                write!(f, "There are duplicated indexes")?;
            }
            TreeError::SecretError => {
                write!(f, "Wrong Secret size")?;
            }
        }
        Ok(())
    }
}

impl std::error::Error for TreeError {}