miden-crypto/src/merkle/simple_smt/tests.rs
src/merkle/simple_smt/tests.rsRaw
1use super::{
2 super::{InnerNodeInfo, MerkleError, MerkleTree, RpoDigest, SimpleSmt},
3 NodeIndex, Rpo256, Vec,
4};
5use crate::{
6 merkle::{digests_to_words, empty_roots::EMPTY_WORD, int_to_leaf, int_to_node},
7 Word,
8};
9
10// TEST DATA
11// ================================================================================================
12
13const KEYS4: [u64; 4] = [0, 1, 2, 3];
14const KEYS8: [u64; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
15
16const VALUES4: [RpoDigest; 4] = [int_to_node(1), int_to_node(2), int_to_node(3), int_to_node(4)];
17
18const VALUES8: [RpoDigest; 8] = [
19 int_to_node(1),
20 int_to_node(2),
21 int_to_node(3),
22 int_to_node(4),
23 int_to_node(5),
24 int_to_node(6),
25 int_to_node(7),
26 int_to_node(8),
27];
28
29const ZERO_VALUES8: [Word; 8] = [int_to_leaf(0); 8];
30
31// TESTS
32// ================================================================================================
33
34#[test]
35fn build_empty_tree() {
36 // tree of depth 3
37 let smt = SimpleSmt::new(3).unwrap();
38 let mt = MerkleTree::new(ZERO_VALUES8.to_vec()).unwrap();
39 assert_eq!(mt.root(), smt.root());
40}
41
42#[test]
43fn build_sparse_tree() {
44 let mut smt = SimpleSmt::new(3).unwrap();
45 let mut values = ZERO_VALUES8.to_vec();
46
47 // insert single value
48 let key = 6;
49 let new_node = int_to_leaf(7);
50 values[key as usize] = new_node;
51 let old_value = smt.update_leaf(key, new_node).expect("Failed to update leaf");
52 let mt2 = MerkleTree::new(values.clone()).unwrap();
53 assert_eq!(mt2.root(), smt.root());
54 assert_eq!(
55 mt2.get_path(NodeIndex::make(3, 6)).unwrap(),
56 smt.get_path(NodeIndex::make(3, 6)).unwrap()
57 );
58 assert_eq!(old_value, EMPTY_WORD);
59
60 // insert second value at distinct leaf branch
61 let key = 2;
62 let new_node = int_to_leaf(3);
63 values[key as usize] = new_node;
64 let old_value = smt.update_leaf(key, new_node).expect("Failed to update leaf");
65 let mt3 = MerkleTree::new(values).unwrap();
66 assert_eq!(mt3.root(), smt.root());
67 assert_eq!(
68 mt3.get_path(NodeIndex::make(3, 2)).unwrap(),
69 smt.get_path(NodeIndex::make(3, 2)).unwrap()
70 );
71 assert_eq!(old_value, EMPTY_WORD);
72}
73
74#[test]
75fn test_depth2_tree() {
76 let tree =
77 SimpleSmt::with_leaves(2, KEYS4.into_iter().zip(digests_to_words(&VALUES4).into_iter()))
78 .unwrap();
79
80 // check internal structure
81 let (root, node2, node3) = compute_internal_nodes();
82 assert_eq!(root, tree.root());
83 assert_eq!(node2, tree.get_node(NodeIndex::make(1, 0)).unwrap());
84 assert_eq!(node3, tree.get_node(NodeIndex::make(1, 1)).unwrap());
85
86 // check get_node()
87 assert_eq!(VALUES4[0], tree.get_node(NodeIndex::make(2, 0)).unwrap());
88 assert_eq!(VALUES4[1], tree.get_node(NodeIndex::make(2, 1)).unwrap());
89 assert_eq!(VALUES4[2], tree.get_node(NodeIndex::make(2, 2)).unwrap());
90 assert_eq!(VALUES4[3], tree.get_node(NodeIndex::make(2, 3)).unwrap());
91
92 // check get_path(): depth 2
93 assert_eq!(vec![VALUES4[1], node3], *tree.get_path(NodeIndex::make(2, 0)).unwrap());
94 assert_eq!(vec![VALUES4[0], node3], *tree.get_path(NodeIndex::make(2, 1)).unwrap());
95 assert_eq!(vec![VALUES4[3], node2], *tree.get_path(NodeIndex::make(2, 2)).unwrap());
96 assert_eq!(vec![VALUES4[2], node2], *tree.get_path(NodeIndex::make(2, 3)).unwrap());
97
98 // check get_path(): depth 1
99 assert_eq!(vec![node3], *tree.get_path(NodeIndex::make(1, 0)).unwrap());
100 assert_eq!(vec![node2], *tree.get_path(NodeIndex::make(1, 1)).unwrap());
101}
102
103#[test]
104fn test_inner_node_iterator() -> Result<(), MerkleError> {
105 let tree =
106 SimpleSmt::with_leaves(2, KEYS4.into_iter().zip(digests_to_words(&VALUES4).into_iter()))
107 .unwrap();
108
109 // check depth 2
110 assert_eq!(VALUES4[0], tree.get_node(NodeIndex::make(2, 0)).unwrap());
111 assert_eq!(VALUES4[1], tree.get_node(NodeIndex::make(2, 1)).unwrap());
112 assert_eq!(VALUES4[2], tree.get_node(NodeIndex::make(2, 2)).unwrap());
113 assert_eq!(VALUES4[3], tree.get_node(NodeIndex::make(2, 3)).unwrap());
114
115 // get parent nodes
116 let root = tree.root();
117 let l1n0 = tree.get_node(NodeIndex::make(1, 0))?;
118 let l1n1 = tree.get_node(NodeIndex::make(1, 1))?;
119 let l2n0 = tree.get_node(NodeIndex::make(2, 0))?;
120 let l2n1 = tree.get_node(NodeIndex::make(2, 1))?;
121 let l2n2 = tree.get_node(NodeIndex::make(2, 2))?;
122 let l2n3 = tree.get_node(NodeIndex::make(2, 3))?;
123
124 let nodes: Vec<InnerNodeInfo> = tree.inner_nodes().collect();
125 let expected = vec![
126 InnerNodeInfo {
127 value: root,
128 left: l1n0,
129 right: l1n1,
130 },
131 InnerNodeInfo {
132 value: l1n0,
133 left: l2n0,
134 right: l2n1,
135 },
136 InnerNodeInfo {
137 value: l1n1,
138 left: l2n2,
139 right: l2n3,
140 },
141 ];
142 assert_eq!(nodes, expected);
143
144 Ok(())
145}
146
147#[test]
148fn update_leaf() {
149 let mut tree =
150 SimpleSmt::with_leaves(3, KEYS8.into_iter().zip(digests_to_words(&VALUES8).into_iter()))
151 .unwrap();
152
153 // update one value
154 let key = 3;
155 let new_node = int_to_leaf(9);
156 let mut expected_values = digests_to_words(&VALUES8);
157 expected_values[key] = new_node;
158 let expected_tree = MerkleTree::new(expected_values.clone()).unwrap();
159
160 let old_leaf = tree.update_leaf(key as u64, new_node).unwrap();
161 assert_eq!(expected_tree.root(), tree.root);
162 assert_eq!(old_leaf, *VALUES8[key]);
163
164 // update another value
165 let key = 6;
166 let new_node = int_to_leaf(10);
167 expected_values[key] = new_node;
168 let expected_tree = MerkleTree::new(expected_values.clone()).unwrap();
169
170 let old_leaf = tree.update_leaf(key as u64, new_node).unwrap();
171 assert_eq!(expected_tree.root(), tree.root);
172 assert_eq!(old_leaf, *VALUES8[key]);
173}
174
175#[test]
176fn small_tree_opening_is_consistent() {
177 // ____k____
178 // / \
179 // _i_ _j_
180 // / \ / \
181 // e f g h
182 // / \ / \ / \ / \
183 // a b 0 0 c 0 0 d
184
185 let z = EMPTY_WORD;
186
187 let a = Word::from(Rpo256::merge(&[z.into(); 2]));
188 let b = Word::from(Rpo256::merge(&[a.into(); 2]));
189 let c = Word::from(Rpo256::merge(&[b.into(); 2]));
190 let d = Word::from(Rpo256::merge(&[c.into(); 2]));
191
192 let e = Rpo256::merge(&[a.into(), b.into()]);
193 let f = Rpo256::merge(&[z.into(), z.into()]);
194 let g = Rpo256::merge(&[c.into(), z.into()]);
195 let h = Rpo256::merge(&[z.into(), d.into()]);
196
197 let i = Rpo256::merge(&[e, f]);
198 let j = Rpo256::merge(&[g, h]);
199
200 let k = Rpo256::merge(&[i, j]);
201
202 let depth = 3;
203 let entries = vec![(0, a), (1, b), (4, c), (7, d)];
204 let tree = SimpleSmt::with_leaves(depth, entries).unwrap();
205
206 assert_eq!(tree.root(), k);
207
208 let cases: Vec<(u8, u64, Vec<RpoDigest>)> = vec![
209 (3, 0, vec![b.into(), f, j]),
210 (3, 1, vec![a.into(), f, j]),
211 (3, 4, vec![z.into(), h, i]),
212 (3, 7, vec![z.into(), g, i]),
213 (2, 0, vec![f, j]),
214 (2, 1, vec![e, j]),
215 (2, 2, vec![h, i]),
216 (2, 3, vec![g, i]),
217 (1, 0, vec![j]),
218 (1, 1, vec![i]),
219 ];
220
221 for (depth, key, path) in cases {
222 let opening = tree.get_path(NodeIndex::make(depth, key)).unwrap();
223
224 assert_eq!(path, *opening);
225 }
226}
227
228#[test]
229fn fail_on_duplicates() {
230 let entries = [(1_u64, int_to_leaf(1)), (5, int_to_leaf(2)), (1_u64, int_to_leaf(3))];
231 let smt = SimpleSmt::with_leaves(64, entries);
232 assert!(smt.is_err());
233
234 let entries = [(1_u64, int_to_leaf(0)), (5, int_to_leaf(2)), (1_u64, int_to_leaf(0))];
235 let smt = SimpleSmt::with_leaves(64, entries);
236 assert!(smt.is_err());
237
238 let entries = [(1_u64, int_to_leaf(0)), (5, int_to_leaf(2)), (1_u64, int_to_leaf(1))];
239 let smt = SimpleSmt::with_leaves(64, entries);
240 assert!(smt.is_err());
241
242 let entries = [(1_u64, int_to_leaf(1)), (5, int_to_leaf(2)), (1_u64, int_to_leaf(0))];
243 let smt = SimpleSmt::with_leaves(64, entries);
244 assert!(smt.is_err());
245}
246
247#[test]
248fn with_no_duplicates_empty_node() {
249 let entries = [(1_u64, int_to_leaf(0)), (5, int_to_leaf(2))];
250 let smt = SimpleSmt::with_leaves(64, entries);
251 assert!(smt.is_ok());
252}
253
254// HELPER FUNCTIONS
255// --------------------------------------------------------------------------------------------
256
257fn compute_internal_nodes() -> (RpoDigest, RpoDigest, RpoDigest) {
258 let node2 = Rpo256::merge(&[VALUES4[0], VALUES4[1]]);
259 let node3 = Rpo256::merge(&[VALUES4[2], VALUES4[3]]);
260 let root = Rpo256::merge(&[node2, node3]);
261
262 (root, node2, node3)
263}