miden-crypto 0.25.0

Miden Cryptographic primitives
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Adapter used only by the `miden-crypto` executable benchmark.
//!
//! The executable chooses memory or RocksDB storage at runtime. This wrapper erases the concrete
//! storage type while preserving the associated reader type needed by `SmtStorage`.

use miden_crypto::{
    Map, Word,
    merkle::smt::{InnerNode, SmtLeaf, SmtStorage, SmtStorageReader, StorageError, StorageUpdates},
};

pub(crate) type BoxedSmtStorage = Box<dyn SmtStorage<Reader = Box<dyn SmtStorageReader>>>;

#[derive(Debug)]
pub(crate) struct BoxedStorage<T>(pub(crate) T);

impl<T: SmtStorageReader> SmtStorageReader for BoxedStorage<T> {
    fn leaf_count(&self) -> Result<usize, StorageError> {
        self.0.leaf_count()
    }
    fn entry_count(&self) -> Result<usize, StorageError> {
        self.0.entry_count()
    }
    fn get_leaf(&self, index: u64) -> Result<Option<SmtLeaf>, StorageError> {
        self.0.get_leaf(index)
    }
    fn get_leaves(&self, indices: &[u64]) -> Result<Vec<Option<SmtLeaf>>, StorageError> {
        self.0.get_leaves(indices)
    }
    fn has_leaves(&self) -> Result<bool, StorageError> {
        self.0.has_leaves()
    }
    fn get_subtree(
        &self,
        index: miden_crypto::merkle::NodeIndex,
    ) -> Result<Option<miden_crypto::merkle::smt::Subtree>, StorageError> {
        self.0.get_subtree(index)
    }
    fn get_subtrees(
        &self,
        indices: &[miden_crypto::merkle::NodeIndex],
    ) -> Result<Vec<Option<miden_crypto::merkle::smt::Subtree>>, StorageError> {
        self.0.get_subtrees(indices)
    }
    fn get_leaf_and_subtrees(
        &self,
        leaf_index: u64,
        subtree_indices: &[miden_crypto::merkle::NodeIndex],
    ) -> Result<(Option<SmtLeaf>, Vec<Option<miden_crypto::merkle::smt::Subtree>>), StorageError>
    {
        self.0.get_leaf_and_subtrees(leaf_index, subtree_indices)
    }
    fn get_inner_node(
        &self,
        index: miden_crypto::merkle::NodeIndex,
    ) -> Result<Option<InnerNode>, StorageError> {
        self.0.get_inner_node(index)
    }
    fn iter_leaves(&self) -> Result<Box<dyn Iterator<Item = (u64, SmtLeaf)> + '_>, StorageError> {
        self.0.iter_leaves()
    }
    fn iter_subtrees(
        &self,
    ) -> Result<Box<dyn Iterator<Item = miden_crypto::merkle::smt::Subtree> + '_>, StorageError>
    {
        self.0.iter_subtrees()
    }
    fn get_depth24(&self) -> Result<Vec<(u64, Word)>, StorageError> {
        self.0.get_depth24()
    }
}

impl<T: SmtStorage> SmtStorage for BoxedStorage<T> {
    type Reader = Box<dyn SmtStorageReader>;

    fn reader(&self) -> Result<Self::Reader, StorageError> {
        Ok(Box::new(BoxedStorage(self.0.reader()?)))
    }
    fn insert_value(
        &mut self,
        index: u64,
        key: Word,
        value: Word,
    ) -> Result<Option<Word>, StorageError> {
        self.0.insert_value(index, key, value)
    }
    fn remove_value(&mut self, index: u64, key: Word) -> Result<Option<Word>, StorageError> {
        self.0.remove_value(index, key)
    }
    fn set_leaves(&mut self, leaves: Map<u64, SmtLeaf>) -> Result<(), StorageError> {
        self.0.set_leaves(leaves)
    }
    fn remove_leaf(&mut self, index: u64) -> Result<Option<SmtLeaf>, StorageError> {
        self.0.remove_leaf(index)
    }
    fn set_subtree(
        &mut self,
        subtree: &miden_crypto::merkle::smt::Subtree,
    ) -> Result<(), StorageError> {
        self.0.set_subtree(subtree)
    }
    fn set_subtrees(
        &mut self,
        subtrees: Vec<miden_crypto::merkle::smt::Subtree>,
    ) -> Result<(), StorageError> {
        self.0.set_subtrees(subtrees)
    }
    fn remove_subtree(
        &mut self,
        index: miden_crypto::merkle::NodeIndex,
    ) -> Result<(), StorageError> {
        self.0.remove_subtree(index)
    }
    fn set_inner_node(
        &mut self,
        index: miden_crypto::merkle::NodeIndex,
        node: InnerNode,
    ) -> Result<Option<InnerNode>, StorageError> {
        self.0.set_inner_node(index, node)
    }
    fn remove_inner_node(
        &mut self,
        index: miden_crypto::merkle::NodeIndex,
    ) -> Result<Option<InnerNode>, StorageError> {
        self.0.remove_inner_node(index)
    }
    fn apply(&mut self, updates: StorageUpdates) -> Result<(), StorageError> {
        self.0.apply(updates)
    }
}