qyriad/miden-crypto
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: added From convertions for the MerkleStore

Browse source
This commit is contained in:
Augusto F. Hack 2023-04-21 14:45:50 +02:00
parent eb316f51bc
commit 59595a2e04
No known key found for this signature in database
GPG key ID: 3F3584B7FB1DFB76
3 changed files with 52 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
benches/store.rs
View file

@ -34,7 +34,7 @@ fn get_empty_leaf_simplesmt(c: &mut Criterion) {
// both SMT and the store are pre-populated with empty hashes, accessing these values is what is
// being benchmarked here, so no values are inserted into the backends
let smt = SimpleSmt::new(depth).unwrap();
let store = MerkleStore::new();
let store: MerkleStore = smt.clone().into();
let root = smt.root();
group.bench_function(BenchmarkId::new("SimpleSmt", depth), |b| {
@ -66,8 +66,7 @@ fn get_leaf_merkletree(c: &mut Criterion) {
let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
let mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let depth = mtree.depth();
let root = mtree.root();
let size_u64 = size as u64;
@ -109,8 +108,7 @@ fn get_leaf_simplesmt(c: &mut Criterion) {
.unwrap()
.with_leaves(smt_leaves.clone())
.unwrap();
let mut store = MerkleStore::new();
store.extend(smt.inner_nodes());
let store: MerkleStore = smt.clone().into();
let depth = smt.depth();
let root = smt.root();
let size_u64 = size as u64;
@ -143,7 +141,7 @@ fn get_node_of_empty_simplesmt(c: &mut Criterion) {
// of these values is what is being benchmarked here, so no values are inserted into the
// backends.
let smt = SimpleSmt::new(depth).unwrap();
let store = MerkleStore::new();
let store: MerkleStore = smt.clone().into();
let root = smt.root();
let half_depth = depth / 2;
let half_size = 2_u64.pow(half_depth as u32);
@ -178,8 +176,7 @@ fn get_node_merkletree(c: &mut Criterion) {
let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
let mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let root = mtree.root();
let half_depth = mtree.depth() / 2;
let half_size = 2_u64.pow(half_depth as u32);
@ -222,8 +219,7 @@ fn get_node_simplesmt(c: &mut Criterion) {
.unwrap()
.with_leaves(smt_leaves.clone())
.unwrap();
let mut store = MerkleStore::new();
store.extend(smt.inner_nodes());
let store: MerkleStore = smt.clone().into();
let root = smt.root();
let half_depth = smt.depth() / 2;
let half_size = 2_u64.pow(half_depth as u32);
@ -258,8 +254,7 @@ fn get_leaf_path_merkletree(c: &mut Criterion) {
let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
let mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let depth = mtree.depth();
let root = mtree.root();
let size_u64 = size as u64;
@ -301,8 +296,7 @@ fn get_leaf_path_simplesmt(c: &mut Criterion) {
.unwrap()
.with_leaves(smt_leaves.clone())
.unwrap();
let mut store = MerkleStore::new();
store.extend(smt.inner_nodes());
let store: MerkleStore = smt.clone().into();
let depth = smt.depth();
let root = smt.root();
let size_u64 = size as u64;
@ -352,7 +346,7 @@ fn new(c: &mut Criterion) {
|| leaves.iter().map(|v| v.into()).collect::<Vec<Word>>(),
|l| {
let mtree = MerkleTree::new(l).unwrap();
black_box(MerkleStore::new().extend(mtree.inner_nodes()));
black_box(MerkleStore::from(mtree));
},
BatchSize::SmallInput,
)
@ -383,7 +377,7 @@ fn new(c: &mut Criterion) {
},
|l| {
let smt = SimpleSmt::new(SimpleSmt::MAX_DEPTH).unwrap().with_leaves(l).unwrap();
black_box(MerkleStore::new().extend(smt.inner_nodes()));
black_box(MerkleStore::from(smt));
},
BatchSize::SmallInput,
)
@ -403,8 +397,7 @@ fn update_leaf_merkletree(c: &mut Criterion) {
let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
let mut mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let mut store: MerkleStore = mtree.clone().into();
let depth = mtree.depth();
let root = mtree.root();
let size_u64 = size as u64;
@ -453,8 +446,7 @@ fn update_leaf_simplesmt(c: &mut Criterion) {
.unwrap()
.with_leaves(smt_leaves.clone())
.unwrap();
let mut store = MerkleStore::new();
store.extend(smt.inner_nodes());
let mut store: MerkleStore = smt.clone().into();
let depth = smt.depth();
let root = smt.root();
let size_u64 = size as u64;

31
src/merkle/store/mod.rs
View file

@ -1,7 +1,7 @@
use super::mmr::Mmr;
use super::{
BTreeMap, EmptySubtreeRoots, InnerNodeInfo, MerkleError, MerklePath, MerklePathSet, NodeIndex,
RootPath, Rpo256, RpoDigest, ValuePath, Vec, Word,
BTreeMap, EmptySubtreeRoots, InnerNodeInfo, MerkleError, MerklePath, MerklePathSet, MerkleTree,
NodeIndex, RootPath, Rpo256, RpoDigest, SimpleSmt, ValuePath, Vec, Word,
};
use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
@ -393,6 +393,33 @@ impl MerkleStore {
}
}
// CONVERTIONS
// ================================================================================================
impl From<MerkleTree> for MerkleStore {
fn from(value: MerkleTree) -> Self {
let mut store = MerkleStore::new();
store.extend(value.inner_nodes());
store
}
}
impl From<SimpleSmt> for MerkleStore {
fn from(value: SimpleSmt) -> Self {
let mut store = MerkleStore::new();
store.extend(value.inner_nodes());
store
}
}
impl From<Mmr> for MerkleStore {
fn from(value: Mmr) -> Self {
let mut store = MerkleStore::new();
store.extend(value.inner_nodes());
store
}
}
// ITERATORS
// ================================================================================================

33
src/merkle/store/tests.rs
View file

@ -15,8 +15,7 @@ const EMPTY: Word = [ZERO; WORD_SIZE];
#[test]
fn test_root_not_in_store() -> Result<(), MerkleError> {
let mtree = MerkleTree::new(LEAVES4.to_vec())?;
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
assert_eq!(
store.get_node(LEAVES4[0], NodeIndex::make(mtree.depth(), 0)),
Err(MerkleError::RootNotInStore(LEAVES4[0])),
@ -34,8 +33,7 @@ fn test_root_not_in_store() -> Result<(), MerkleError> {
#[test]
fn test_merkle_tree() -> Result<(), MerkleError> {
let mtree = MerkleTree::new(LEAVES4.to_vec())?;
let mut store = MerkleStore::default();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
// STORE LEAVES ARE CORRECT ==============================================================
// checks the leaves in the store corresponds to the expected values
@ -177,8 +175,7 @@ fn test_leaf_paths_for_empty_trees() -> Result<(), MerkleError> {
#[test]
fn test_get_invalid_node() {
let mtree = MerkleTree::new(LEAVES4.to_vec()).expect("creating a merkle tree must work");
let mut store = MerkleStore::default();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let _ = store.get_node(mtree.root(), NodeIndex::make(mtree.depth(), 3));
}
@ -190,8 +187,7 @@ fn test_add_sparse_merkle_tree_one_level() -> Result<(), MerkleError> {
.unwrap()
.with_leaves(keys2.into_iter().zip(leaves2.into_iter()))
.unwrap();
let mut store = MerkleStore::default();
store.extend(smt.inner_nodes());
let store: MerkleStore = smt.clone().into();
let idx = NodeIndex::make(1, 0);
assert_eq!(smt.get_node(idx).unwrap(), leaves2[0]);
@ -211,8 +207,7 @@ fn test_sparse_merkle_tree() -> Result<(), MerkleError> {
.with_leaves(KEYS4.into_iter().zip(LEAVES4.into_iter()))
.unwrap();
let mut store = MerkleStore::default();
store.extend(smt.inner_nodes());
let store: MerkleStore = smt.clone().into();
// STORE LEAVES ARE CORRECT ==============================================================
// checks the leaves in the store corresponds to the expected values
@ -470,8 +465,7 @@ fn wont_open_to_different_depth_root() {
// attempt to fetch a node on the maximum depth, and it should fail because the root shouldn't
// exist for the set.
let mtree = MerkleTree::new(vec![a, b]).unwrap();
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let index = NodeIndex::root();
let err = store.get_node(root, index).err().unwrap();
assert_eq!(err, MerkleError::RootNotInStore(root));
@ -499,8 +493,7 @@ fn store_path_opens_from_leaf() {
let root = Rpo256::merge(&[m.into(), n.into()]);
let mtree = MerkleTree::new(vec![a, b, c, d, e, f, g, h]).unwrap();
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let path = store.get_path(root.into(), NodeIndex::make(3, 1)).unwrap().path;
let expected = MerklePath::new([a.into(), j.into(), n.into()].to_vec());
@ -510,8 +503,7 @@ fn store_path_opens_from_leaf() {
#[test]
fn test_set_node() -> Result<(), MerkleError> {
let mtree = MerkleTree::new(LEAVES4.to_vec())?;
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let mut store: MerkleStore = mtree.clone().into();
let value = int_to_node(42);
let index = NodeIndex::make(mtree.depth(), 0);
let new_root = store.set_node(mtree.root(), index, value)?.root;
@ -523,8 +515,7 @@ fn test_set_node() -> Result<(), MerkleError> {
#[test]
fn test_constructors() -> Result<(), MerkleError> {
let mtree = MerkleTree::new(LEAVES4.to_vec())?;
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let depth = mtree.depth();
let leaves = 2u64.pow(depth.into());
@ -539,8 +530,7 @@ fn test_constructors() -> Result<(), MerkleError> {
.unwrap()
.with_leaves(KEYS4.into_iter().zip(LEAVES4.into_iter()))
.unwrap();
let mut store = MerkleStore::new();
store.extend(smt.inner_nodes());
let store: MerkleStore = smt.clone().into();
let depth = smt.depth();
for key in KEYS4 {
@ -730,8 +720,7 @@ fn get_leaf_depth_works_with_depth_8() {
#[test]
fn test_serialization() -> Result<(), Box<dyn Error>> {
let mtree = MerkleTree::new(LEAVES4.to_vec())?;
let mut store = MerkleStore::new();
store.extend(mtree.inner_nodes());
let store: MerkleStore = mtree.clone().into();
let decoded = MerkleStore::read_from_bytes(&original.to_bytes())?;
assert_eq!(original, decoded);
Ok(())