Bobbin Threadbare
4 months ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 448 additions and 399 deletions
Split View
Diff Options
-
+7 -1CHANGELOG.md
-
+75 -47Cargo.lock
-
+10 -8Cargo.toml
-
+63 -22src/hash/rescue/rpo/digest.rs
-
+63 -22src/hash/rescue/rpx/digest.rs
-
+25 -56src/merkle/error.rs
-
+6 -5src/merkle/index.rs
-
+21 -35src/merkle/mmr/error.rs
-
+7 -4src/merkle/mmr/full.rs
-
+10 -5src/merkle/mmr/partial.rs
-
+7 -3src/merkle/mmr/peaks.rs
-
+15 -9src/merkle/partial_mt/mod.rs
-
+4 -1src/merkle/path.rs
-
+17 -64src/merkle/smt/full/error.rs
-
+8 -7src/merkle/smt/full/leaf.rs
-
+1 -1src/merkle/smt/full/proof.rs
-
+5 -2src/merkle/smt/mod.rs
-
+2 -2src/merkle/smt/simple/mod.rs
-
+4 -2src/merkle/smt/simple/tests.rs
-
+8 -2src/merkle/store/mod.rs
-
+76 -75src/merkle/store/tests.rs
-
+4 -2src/rand/rpo.rs
-
+10 -24src/utils/mod.rs
@ -1,65 +1,34 @@ |
|||
use alloc::vec::Vec;
|
|||
use core::fmt;
|
|||
use thiserror::Error;
|
|||
|
|||
use super::{smt::SmtLeafError, MerklePath, NodeIndex, RpoDigest};
|
|||
use super::{NodeIndex, RpoDigest};
|
|||
|
|||
#[derive(Clone, Debug, PartialEq, Eq)]
|
|||
#[derive(Debug, Error)]
|
|||
pub enum MerkleError {
|
|||
ConflictingRoots(Vec<RpoDigest>),
|
|||
#[error("expected merkle root {expected_root} found {actual_root}")]
|
|||
ConflictingRoots {
|
|||
expected_root: RpoDigest,
|
|||
actual_root: RpoDigest,
|
|||
},
|
|||
#[error("provided merkle tree depth {0} is too small")]
|
|||
DepthTooSmall(u8),
|
|||
#[error("provided merkle tree depth {0} is too big")]
|
|||
DepthTooBig(u64),
|
|||
#[error("multiple values provided for merkle tree index {0}")]
|
|||
DuplicateValuesForIndex(u64),
|
|||
DuplicateValuesForKey(RpoDigest),
|
|||
InvalidIndex { depth: u8, value: u64 },
|
|||
InvalidDepth { expected: u8, provided: u8 },
|
|||
InvalidSubtreeDepth { subtree_depth: u8, tree_depth: u8 },
|
|||
InvalidPath(MerklePath),
|
|||
InvalidNumEntries(usize),
|
|||
NodeNotInSet(NodeIndex),
|
|||
NodeNotInStore(RpoDigest, NodeIndex),
|
|||
#[error("node index value {value} is not valid for depth {depth}")]
|
|||
InvalidNodeIndex { depth: u8, value: u64 },
|
|||
#[error("provided node index depth {provided} does not match expected depth {expected}")]
|
|||
InvalidNodeIndexDepth { expected: u8, provided: u8 },
|
|||
#[error("merkle subtree depth {subtree_depth} exceeds merkle tree depth {tree_depth}")]
|
|||
SubtreeDepthExceedsDepth { subtree_depth: u8, tree_depth: u8 },
|
|||
#[error("number of entries in the merkle tree exceeds the maximum of {0}")]
|
|||
TooManyEntries(usize),
|
|||
#[error("node index `{0}` not found in the tree")]
|
|||
NodeIndexNotFoundInTree(NodeIndex),
|
|||
#[error("node {0:?} with index `{1}` not found in the store")]
|
|||
NodeIndexNotFoundInStore(RpoDigest, NodeIndex),
|
|||
#[error("number of provided merkle tree leaves {0} is not a power of two")]
|
|||
NumLeavesNotPowerOfTwo(usize),
|
|||
#[error("root {0:?} is not in the store")]
|
|||
RootNotInStore(RpoDigest),
|
|||
SmtLeaf(SmtLeafError),
|
|||
}
|
|||
|
|||
impl fmt::Display for MerkleError {
|
|||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|||
use MerkleError::*;
|
|||
match self {
|
|||
ConflictingRoots(roots) => write!(f, "the merkle paths roots do not match {roots:?}"),
|
|||
DepthTooSmall(depth) => write!(f, "the provided depth {depth} is too small"),
|
|||
DepthTooBig(depth) => write!(f, "the provided depth {depth} is too big"),
|
|||
DuplicateValuesForIndex(key) => write!(f, "multiple values provided for key {key}"),
|
|||
DuplicateValuesForKey(key) => write!(f, "multiple values provided for key {key}"),
|
|||
InvalidIndex { depth, value } => {
|
|||
write!(f, "the index value {value} is not valid for the depth {depth}")
|
|||
},
|
|||
InvalidDepth { expected, provided } => {
|
|||
write!(f, "the provided depth {provided} is not valid for {expected}")
|
|||
},
|
|||
InvalidSubtreeDepth { subtree_depth, tree_depth } => {
|
|||
write!(f, "tried inserting a subtree of depth {subtree_depth} into a tree of depth {tree_depth}")
|
|||
},
|
|||
InvalidPath(_path) => write!(f, "the provided path is not valid"),
|
|||
InvalidNumEntries(max) => write!(f, "number of entries exceeded the maximum: {max}"),
|
|||
NodeNotInSet(index) => write!(f, "the node with index ({index}) is not in the set"),
|
|||
NodeNotInStore(hash, index) => {
|
|||
write!(f, "the node {hash:?} with index ({index}) is not in the store")
|
|||
},
|
|||
NumLeavesNotPowerOfTwo(leaves) => {
|
|||
write!(f, "the leaves count {leaves} is not a power of 2")
|
|||
},
|
|||
RootNotInStore(root) => write!(f, "the root {:?} is not in the store", root),
|
|||
SmtLeaf(smt_leaf_error) => write!(f, "smt leaf error: {smt_leaf_error}"),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[cfg(feature = "std")]
|
|||
impl std::error::Error for MerkleError {}
|
|||
|
|||
impl From<SmtLeafError> for MerkleError {
|
|||
fn from(value: SmtLeafError) -> Self {
|
|||
Self::SmtLeaf(value)
|
|||
}
|
|||
}
|
|||
@ -1,41 +1,27 @@ |
|||
use core::fmt::{Display, Formatter};
|
|||
#[cfg(feature = "std")]
|
|||
use std::error::Error;
|
|||
use alloc::string::String;
|
|||
|
|||
use thiserror::Error;
|
|||
|
|||
use crate::merkle::MerkleError;
|
|||
|
|||
#[derive(Debug, PartialEq, Eq, Clone)]
|
|||
#[derive(Debug, Error)]
|
|||
pub enum MmrError {
|
|||
InvalidPosition(usize),
|
|||
InvalidPeaks,
|
|||
InvalidPeak,
|
|||
PeakOutOfBounds(usize, usize),
|
|||
#[error("mmr does not contain position {0}")]
|
|||
PositionNotFound(usize),
|
|||
#[error("mmr peaks are invalid: {0}")]
|
|||
InvalidPeaks(String),
|
|||
#[error(
|
|||
"mmr peak does not match the computed merkle root of the provided authentication path"
|
|||
)]
|
|||
PeakPathMismatch,
|
|||
#[error("requested peak index is {peak_idx} but the number of peaks is {peaks_len}")]
|
|||
PeakOutOfBounds { peak_idx: usize, peaks_len: usize },
|
|||
#[error("invalid mmr update")]
|
|||
InvalidUpdate,
|
|||
UnknownPeak,
|
|||
MerkleError(MerkleError),
|
|||
}
|
|||
|
|||
impl Display for MmrError {
|
|||
fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
|
|||
match self {
|
|||
MmrError::InvalidPosition(pos) => write!(fmt, "Mmr does not contain position {pos}"),
|
|||
MmrError::InvalidPeaks => write!(fmt, "Invalid peaks count"),
|
|||
MmrError::InvalidPeak => {
|
|||
write!(fmt, "Peak values does not match merkle path computed root")
|
|||
},
|
|||
MmrError::PeakOutOfBounds(peak_idx, peaks_len) => write!(
|
|||
fmt,
|
|||
"Requested peak index is {} but the number of peaks is {}",
|
|||
peak_idx, peaks_len
|
|||
),
|
|||
MmrError::InvalidUpdate => write!(fmt, "Invalid Mmr update"),
|
|||
MmrError::UnknownPeak => {
|
|||
write!(fmt, "Peak not in Mmr")
|
|||
},
|
|||
MmrError::MerkleError(err) => write!(fmt, "{}", err),
|
|||
}
|
|||
}
|
|||
#[error("mmr does not contain a peak with depth {0}")]
|
|||
UnknownPeak(u8),
|
|||
#[error("invalid merkle path")]
|
|||
InvalidMerklePath(#[source] MerkleError),
|
|||
#[error("merkle root computation failed")]
|
|||
MerkleRootComputationFailed(#[source] MerkleError),
|
|||
}
|
|||
|
|||
#[cfg(feature = "std")]
|
|||
impl Error for MmrError {}
|
|||
@ -1,86 +1,39 @@ |
|||
use alloc::vec::Vec;
|
|||
use core::fmt;
|
|||
use thiserror::Error;
|
|||
|
|||
use crate::{
|
|||
hash::rpo::RpoDigest,
|
|||
merkle::{LeafIndex, SMT_DEPTH},
|
|||
Word,
|
|||
};
|
|||
|
|||
// SMT LEAF ERROR
|
|||
// =================================================================================================
|
|||
|
|||
#[derive(Clone, Debug, PartialEq, Eq)]
|
|||
#[derive(Debug, Error)]
|
|||
pub enum SmtLeafError {
|
|||
InconsistentKeys {
|
|||
entries: Vec<(RpoDigest, Word)>,
|
|||
key_1: RpoDigest,
|
|||
key_2: RpoDigest,
|
|||
},
|
|||
InvalidNumEntriesForMultiple(usize),
|
|||
SingleKeyInconsistentWithLeafIndex {
|
|||
#[error(
|
|||
"multiple leaf requires all keys to map to the same leaf index but key1 {key_1} and key2 {key_2} map to different indices"
|
|||
)]
|
|||
InconsistentMultipleLeafKeys { key_1: RpoDigest, key_2: RpoDigest },
|
|||
#[error("single leaf key {key} maps to {actual_leaf_index:?} but was expected to map to {expected_leaf_index:?}")]
|
|||
InconsistentSingleLeafIndices {
|
|||
key: RpoDigest,
|
|||
leaf_index: LeafIndex<SMT_DEPTH>,
|
|||
expected_leaf_index: LeafIndex<SMT_DEPTH>,
|
|||
actual_leaf_index: LeafIndex<SMT_DEPTH>,
|
|||
},
|
|||
MultipleKeysInconsistentWithLeafIndex {
|
|||
#[error("supplied leaf index {leaf_index_supplied:?} does not match {leaf_index_from_keys:?} for multiple leaf")]
|
|||
InconsistentMultipleLeafIndices {
|
|||
leaf_index_from_keys: LeafIndex<SMT_DEPTH>,
|
|||
leaf_index_supplied: LeafIndex<SMT_DEPTH>,
|
|||
},
|
|||
}
|
|||
|
|||
#[cfg(feature = "std")]
|
|||
impl std::error::Error for SmtLeafError {}
|
|||
|
|||
impl fmt::Display for SmtLeafError {
|
|||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|||
use SmtLeafError::*;
|
|||
match self {
|
|||
InvalidNumEntriesForMultiple(num_entries) => {
|
|||
write!(f, "Multiple leaf requires 2 or more entries. Got: {num_entries}")
|
|||
},
|
|||
InconsistentKeys { entries, key_1, key_2 } => {
|
|||
write!(f, "Multiple leaf requires all keys to map to the same leaf index. Offending keys: {key_1} and {key_2}. Entries: {entries:?}.")
|
|||
},
|
|||
SingleKeyInconsistentWithLeafIndex { key, leaf_index } => {
|
|||
write!(
|
|||
f,
|
|||
"Single key in leaf inconsistent with leaf index. Key: {key}, leaf index: {}",
|
|||
leaf_index.value()
|
|||
)
|
|||
},
|
|||
MultipleKeysInconsistentWithLeafIndex {
|
|||
leaf_index_from_keys,
|
|||
leaf_index_supplied,
|
|||
} => {
|
|||
write!(
|
|||
f,
|
|||
"Keys in entries map to leaf index {}, but leaf index {} was supplied",
|
|||
leaf_index_from_keys.value(),
|
|||
leaf_index_supplied.value()
|
|||
)
|
|||
},
|
|||
}
|
|||
}
|
|||
#[error("multiple leaf requires at least two entries but only {0} were given")]
|
|||
MultipleLeafRequiresTwoEntries(usize),
|
|||
}
|
|||
|
|||
// SMT PROOF ERROR
|
|||
// =================================================================================================
|
|||
|
|||
#[derive(Clone, Debug, PartialEq, Eq)]
|
|||
#[derive(Debug, Error)]
|
|||
pub enum SmtProofError {
|
|||
InvalidPathLength(usize),
|
|||
}
|
|||
|
|||
#[cfg(feature = "std")]
|
|||
impl std::error::Error for SmtProofError {}
|
|||
|
|||
impl fmt::Display for SmtProofError {
|
|||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|||
use SmtProofError::*;
|
|||
match self {
|
|||
InvalidPathLength(path_length) => {
|
|||
write!(f, "Invalid Merkle path length. Expected {SMT_DEPTH}, got {path_length}")
|
|||
},
|
|||
}
|
|||
}
|
|||
#[error("merkle path length {0} does not match SMT depth {SMT_DEPTH}")]
|
|||
InvalidMerklePathLength(usize),
|
|||
}
|
|||