mirror of
https://github.com/logos-blockchain/lssa.git
synced 2026-01-08 00:03:09 +00:00
refactor mt
This commit is contained in:
Sergio Chouhy
parent
f2a7c574e5
commit
2e371300d3
@ -18,3 +18,4 @@ hex = "0.4.3"
|
||||
|
||||
[dev-dependencies]
|
||||
test-program-methods = { path = "test_program_methods" }
|
||||
hex-literal = "1.0.0"
|
||||
|
||||
@ -1,130 +1,36 @@
|
||||
use hex_literal::hex;
|
||||
|
||||
pub(crate) const DEFAULT_VALUES: [[u8; 32]; 32] = [
|
||||
[
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0,
|
||||
],
|
||||
[
|
||||
245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35,
|
||||
32, 217, 240, 232, 234, 152, 49, 169, 39, 89, 251, 75,
|
||||
],
|
||||
[
|
||||
219, 86, 17, 78, 0, 253, 212, 193, 248, 92, 137, 43, 243, 90, 201, 168, 146, 137, 170, 236,
|
||||
177, 235, 208, 169, 108, 222, 96, 106, 116, 139, 93, 113,
|
||||
],
|
||||
[
|
||||
199, 128, 9, 253, 240, 127, 197, 106, 17, 241, 34, 55, 6, 88, 163, 83, 170, 165, 66, 237,
|
||||
99, 228, 76, 75, 193, 95, 244, 205, 16, 90, 179, 60,
|
||||
],
|
||||
[
|
||||
83, 109, 152, 131, 127, 45, 209, 101, 165, 93, 94, 234, 233, 20, 133, 149, 68, 114, 213,
|
||||
111, 36, 109, 242, 86, 191, 60, 174, 25, 53, 42, 18, 60,
|
||||
],
|
||||
[
|
||||
158, 253, 224, 82, 170, 21, 66, 159, 174, 5, 186, 212, 208, 177, 215, 198, 77, 166, 77, 3,
|
||||
215, 161, 133, 74, 88, 140, 44, 184, 67, 12, 13, 48,
|
||||
],
|
||||
[
|
||||
216, 141, 223, 238, 212, 0, 168, 117, 85, 150, 178, 25, 66, 193, 73, 126, 17, 76, 48, 46,
|
||||
97, 24, 41, 15, 145, 230, 119, 41, 118, 4, 31, 161,
|
||||
],
|
||||
[
|
||||
135, 235, 13, 219, 165, 126, 53, 246, 210, 134, 103, 56, 2, 164, 175, 89, 117, 226, 37, 6,
|
||||
199, 207, 76, 100, 187, 107, 229, 238, 17, 82, 127, 44,
|
||||
],
|
||||
[
|
||||
38, 132, 100, 118, 253, 95, 197, 74, 93, 67, 56, 81, 103, 201, 81, 68, 242, 100, 63, 83,
|
||||
60, 200, 91, 185, 209, 107, 120, 47, 141, 125, 177, 147,
|
||||
],
|
||||
[
|
||||
80, 109, 134, 88, 45, 37, 36, 5, 184, 64, 1, 135, 146, 202, 210, 191, 18, 89, 241, 239, 90,
|
||||
165, 248, 135, 225, 60, 178, 240, 9, 79, 81, 225,
|
||||
],
|
||||
[
|
||||
255, 255, 10, 215, 230, 89, 119, 47, 149, 52, 193, 149, 200, 21, 239, 196, 1, 78, 241, 225,
|
||||
218, 237, 68, 4, 192, 99, 133, 209, 17, 146, 233, 43,
|
||||
],
|
||||
[
|
||||
108, 240, 65, 39, 219, 5, 68, 28, 216, 51, 16, 122, 82, 190, 133, 40, 104, 137, 14, 67, 23,
|
||||
230, 160, 42, 180, 118, 131, 170, 117, 150, 66, 32,
|
||||
],
|
||||
[
|
||||
183, 208, 95, 135, 95, 20, 0, 39, 239, 81, 24, 162, 36, 123, 187, 132, 206, 143, 47, 15,
|
||||
17, 35, 98, 48, 133, 218, 247, 150, 12, 50, 159, 95,
|
||||
],
|
||||
[
|
||||
223, 106, 245, 245, 187, 219, 107, 233, 239, 138, 166, 24, 228, 191, 128, 115, 150, 8, 103,
|
||||
23, 30, 41, 103, 111, 139, 40, 77, 234, 106, 8, 168, 94,
|
||||
],
|
||||
[
|
||||
181, 141, 144, 15, 94, 24, 46, 60, 80, 239, 116, 150, 158, 161, 108, 119, 38, 197, 73, 117,
|
||||
124, 194, 53, 35, 195, 105, 88, 125, 167, 41, 55, 132,
|
||||
],
|
||||
[
|
||||
212, 154, 117, 2, 255, 207, 176, 52, 11, 29, 120, 133, 104, 133, 0, 202, 48, 129, 97, 167,
|
||||
249, 107, 98, 223, 157, 8, 59, 113, 252, 200, 242, 187,
|
||||
],
|
||||
[
|
||||
143, 230, 177, 104, 146, 86, 192, 211, 133, 244, 47, 91, 190, 32, 39, 162, 44, 25, 150,
|
||||
225, 16, 186, 151, 193, 113, 211, 229, 148, 141, 233, 43, 235,
|
||||
],
|
||||
[
|
||||
141, 13, 99, 195, 158, 186, 222, 133, 9, 224, 174, 60, 156, 56, 118, 251, 95, 161, 18, 190,
|
||||
24, 249, 5, 236, 172, 254, 203, 146, 5, 118, 3, 171,
|
||||
],
|
||||
[
|
||||
149, 238, 200, 178, 229, 65, 202, 212, 233, 29, 227, 131, 133, 242, 224, 70, 97, 159, 84,
|
||||
73, 108, 35, 130, 203, 108, 172, 213, 185, 140, 38, 245, 164,
|
||||
],
|
||||
[
|
||||
248, 147, 233, 8, 145, 119, 117, 182, 43, 255, 35, 41, 77, 187, 227, 161, 205, 142, 108,
|
||||
193, 195, 91, 72, 1, 136, 123, 100, 106, 111, 129, 241, 127,
|
||||
],
|
||||
[
|
||||
205, 219, 167, 181, 146, 227, 19, 51, 147, 193, 97, 148, 250, 199, 67, 26, 191, 47, 84,
|
||||
133, 237, 113, 29, 178, 130, 24, 60, 129, 158, 8, 235, 170,
|
||||
],
|
||||
[
|
||||
138, 141, 127, 227, 175, 140, 170, 8, 90, 118, 57, 168, 50, 0, 20, 87, 223, 185, 18, 138,
|
||||
128, 97, 20, 42, 208, 51, 86, 41, 255, 35, 255, 156,
|
||||
],
|
||||
[
|
||||
254, 179, 195, 55, 215, 165, 26, 111, 191, 0, 185, 227, 76, 82, 225, 201, 25, 92, 150, 155,
|
||||
212, 231, 160, 191, 213, 29, 92, 91, 237, 156, 17, 103,
|
||||
],
|
||||
[
|
||||
231, 31, 10, 168, 60, 195, 46, 223, 190, 250, 159, 77, 62, 1, 116, 202, 133, 24, 46, 236,
|
||||
159, 58, 9, 246, 166, 192, 223, 99, 119, 165, 16, 215,
|
||||
],
|
||||
[
|
||||
49, 32, 111, 168, 10, 80, 187, 106, 190, 41, 8, 80, 88, 241, 98, 18, 33, 42, 96, 238, 200,
|
||||
240, 73, 254, 203, 146, 216, 200, 224, 168, 75, 192,
|
||||
],
|
||||
[
|
||||
33, 53, 43, 254, 203, 237, 221, 233, 147, 131, 159, 97, 76, 61, 172, 10, 62, 227, 117, 67,
|
||||
249, 180, 18, 177, 97, 153, 220, 21, 142, 35, 181, 68,
|
||||
],
|
||||
[
|
||||
97, 158, 49, 39, 36, 187, 109, 124, 49, 83, 237, 157, 231, 145, 215, 100, 163, 102, 179,
|
||||
137, 175, 19, 197, 139, 248, 168, 217, 4, 129, 164, 103, 101,
|
||||
],
|
||||
[
|
||||
124, 221, 41, 134, 38, 130, 80, 98, 141, 12, 16, 227, 133, 197, 140, 97, 145, 230, 251,
|
||||
224, 81, 145, 188, 192, 79, 19, 63, 44, 234, 114, 193, 196,
|
||||
],
|
||||
[
|
||||
132, 137, 48, 189, 123, 168, 202, 197, 70, 97, 7, 33, 19, 251, 39, 136, 105, 224, 123, 184,
|
||||
88, 127, 145, 57, 41, 51, 55, 77, 1, 123, 203, 225,
|
||||
],
|
||||
[
|
||||
136, 105, 255, 44, 34, 178, 140, 193, 5, 16, 217, 133, 50, 146, 128, 51, 40, 190, 79, 176,
|
||||
232, 4, 149, 232, 187, 141, 39, 31, 91, 136, 150, 54,
|
||||
],
|
||||
[
|
||||
181, 254, 40, 231, 159, 27, 133, 15, 134, 88, 36, 108, 233, 182, 161, 231, 180, 159, 192,
|
||||
109, 183, 20, 62, 143, 224, 180, 242, 176, 197, 82, 58, 92,
|
||||
],
|
||||
[
|
||||
152, 94, 146, 159, 112, 175, 40, 208, 189, 209, 169, 10, 128, 143, 151, 127, 89, 124, 124,
|
||||
119, 140, 72, 158, 152, 211, 189, 137, 16, 211, 26, 192, 247,
|
||||
],
|
||||
hex!("0000000000000000000000000000000000000000000000000000000000000000"),
|
||||
hex!("f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b"),
|
||||
hex!("db56114e00fdd4c1f85c892bf35ac9a89289aaecb1ebd0a96cde606a748b5d71"),
|
||||
hex!("c78009fdf07fc56a11f122370658a353aaa542ed63e44c4bc15ff4cd105ab33c"),
|
||||
hex!("536d98837f2dd165a55d5eeae91485954472d56f246df256bf3cae19352a123c"),
|
||||
hex!("9efde052aa15429fae05bad4d0b1d7c64da64d03d7a1854a588c2cb8430c0d30"),
|
||||
hex!("d88ddfeed400a8755596b21942c1497e114c302e6118290f91e6772976041fa1"),
|
||||
hex!("87eb0ddba57e35f6d286673802a4af5975e22506c7cf4c64bb6be5ee11527f2c"),
|
||||
hex!("26846476fd5fc54a5d43385167c95144f2643f533cc85bb9d16b782f8d7db193"),
|
||||
hex!("506d86582d252405b840018792cad2bf1259f1ef5aa5f887e13cb2f0094f51e1"),
|
||||
hex!("ffff0ad7e659772f9534c195c815efc4014ef1e1daed4404c06385d11192e92b"),
|
||||
hex!("6cf04127db05441cd833107a52be852868890e4317e6a02ab47683aa75964220"),
|
||||
hex!("b7d05f875f140027ef5118a2247bbb84ce8f2f0f1123623085daf7960c329f5f"),
|
||||
hex!("df6af5f5bbdb6be9ef8aa618e4bf8073960867171e29676f8b284dea6a08a85e"),
|
||||
hex!("b58d900f5e182e3c50ef74969ea16c7726c549757cc23523c369587da7293784"),
|
||||
hex!("d49a7502ffcfb0340b1d7885688500ca308161a7f96b62df9d083b71fcc8f2bb"),
|
||||
hex!("8fe6b1689256c0d385f42f5bbe2027a22c1996e110ba97c171d3e5948de92beb"),
|
||||
hex!("8d0d63c39ebade8509e0ae3c9c3876fb5fa112be18f905ecacfecb92057603ab"),
|
||||
hex!("95eec8b2e541cad4e91de38385f2e046619f54496c2382cb6cacd5b98c26f5a4"),
|
||||
hex!("f893e908917775b62bff23294dbbe3a1cd8e6cc1c35b4801887b646a6f81f17f"),
|
||||
hex!("cddba7b592e3133393c16194fac7431abf2f5485ed711db282183c819e08ebaa"),
|
||||
hex!("8a8d7fe3af8caa085a7639a832001457dfb9128a8061142ad0335629ff23ff9c"),
|
||||
hex!("feb3c337d7a51a6fbf00b9e34c52e1c9195c969bd4e7a0bfd51d5c5bed9c1167"),
|
||||
hex!("e71f0aa83cc32edfbefa9f4d3e0174ca85182eec9f3a09f6a6c0df6377a510d7"),
|
||||
hex!("31206fa80a50bb6abe29085058f16212212a60eec8f049fecb92d8c8e0a84bc0"),
|
||||
hex!("21352bfecbeddde993839f614c3dac0a3ee37543f9b412b16199dc158e23b544"),
|
||||
hex!("619e312724bb6d7c3153ed9de791d764a366b389af13c58bf8a8d90481a46765"),
|
||||
hex!("7cdd2986268250628d0c10e385c58c6191e6fbe05191bcc04f133f2cea72c1c4"),
|
||||
hex!("848930bd7ba8cac54661072113fb278869e07bb8587f91392933374d017bcbe1"),
|
||||
hex!("8869ff2c22b28cc10510d9853292803328be4fb0e80495e8bb8d271f5b889636"),
|
||||
hex!("b5fe28e79f1b850f8658246ce9b6a1e7b49fc06db7143e8fe0b4f2b0c5523a5c"),
|
||||
hex!("985e929f70af28d0bdd1a90a808f977f597c7c778c489e98d3bd8910d31ac0f7"),
|
||||
];
|
||||
|
||||
@ -23,147 +23,135 @@ fn hash_value(value: &Value) -> Node {
|
||||
|
||||
#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
|
||||
pub struct MerkleTree {
|
||||
index_map: HashMap<Value, usize>,
|
||||
node_map: HashMap<usize, Node>,
|
||||
nodes: Vec<Node>,
|
||||
capacity: usize,
|
||||
length: usize,
|
||||
}
|
||||
|
||||
impl MerkleTree {
|
||||
pub fn root(&self) -> Node {
|
||||
let root_index = self.root_index();
|
||||
*self.get_node(&root_index)
|
||||
*self.get_node(root_index)
|
||||
}
|
||||
|
||||
fn root_index(&self) -> usize {
|
||||
let tree_depth = self.depth();
|
||||
let capacity_depth = self.capacity.trailing_zeros() as usize;
|
||||
let diff = capacity_depth - self.depth();
|
||||
if diff == 0 { 0 } else { (1 << diff) - 1 }
|
||||
}
|
||||
|
||||
fn depth(&self) -> usize {
|
||||
self.index_map.len().next_power_of_two().trailing_zeros() as usize
|
||||
}
|
||||
|
||||
fn get_node(&self, index: &usize) -> &Node {
|
||||
self.node_map.get(&index).unwrap_or_else(|| {
|
||||
let index_depth = usize::BITS as usize - (index + 1).leading_zeros() as usize - 1;
|
||||
let total_levels = self.capacity.trailing_zeros() as usize;
|
||||
if total_levels >= index_depth {
|
||||
&default_values::DEFAULT_VALUES[total_levels - index_depth]
|
||||
if tree_depth == capacity_depth {
|
||||
0
|
||||
} else {
|
||||
//TODO: implement error handling
|
||||
panic!();
|
||||
(1 << (capacity_depth - tree_depth)) - 1
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Number of levels required to hold all values
|
||||
fn depth(&self) -> usize {
|
||||
let result = self.length.next_power_of_two().trailing_zeros() as usize;
|
||||
result
|
||||
}
|
||||
|
||||
fn get_node(&self, index: usize) -> &Node {
|
||||
&self.nodes[index]
|
||||
}
|
||||
|
||||
fn set_node(&mut self, index: usize, node: Node) {
|
||||
self.node_map.insert(index, node);
|
||||
self.nodes[index] = node;
|
||||
}
|
||||
|
||||
pub fn with_capacity(capacity: usize) -> Self {
|
||||
let capacity = capacity.next_power_of_two();
|
||||
let total_depth = capacity.trailing_zeros() as usize;
|
||||
|
||||
let nodes = default_values::DEFAULT_VALUES[..(total_depth + 1)]
|
||||
.iter()
|
||||
.rev()
|
||||
.enumerate()
|
||||
.flat_map(|(level, default_value)| std::iter::repeat_n(default_value, 1 << level))
|
||||
.cloned()
|
||||
.collect();
|
||||
|
||||
Self {
|
||||
index_map: HashMap::with_capacity(capacity),
|
||||
node_map: HashMap::with_capacity(capacity << 1),
|
||||
nodes,
|
||||
capacity,
|
||||
length: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn reallocate_to_double_capacity(&mut self) {
|
||||
let mut this = Self::with_capacity(self.capacity << 1);
|
||||
let mut pairs: Vec<_> = self.index_map.iter().collect();
|
||||
pairs.sort_by_key(|&(_, index)| index);
|
||||
for (value, _) in pairs {
|
||||
this.insert(*value);
|
||||
let old_capacity = self.capacity;
|
||||
let new_capacity = old_capacity << 1;
|
||||
|
||||
let mut this = Self::with_capacity(new_capacity);
|
||||
|
||||
for (index, value) in self.nodes.iter().enumerate() {
|
||||
let offset = prev_power_of_two(index + 1);
|
||||
let new_index = index + offset;
|
||||
this.set_node(new_index, *value);
|
||||
}
|
||||
|
||||
this.length = self.length;
|
||||
|
||||
*self = this;
|
||||
}
|
||||
|
||||
pub fn insert(&mut self, value: Value) -> bool {
|
||||
if self.index_map.contains_key(&value) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if self.capacity == self.index_map.len() {
|
||||
pub fn insert(&mut self, value: Value) -> usize {
|
||||
if self.length == self.capacity {
|
||||
self.reallocate_to_double_capacity();
|
||||
}
|
||||
|
||||
let new_index = self.index_map.len();
|
||||
self.index_map.insert(value, new_index);
|
||||
let new_index = self.length;
|
||||
|
||||
let base_length = self.capacity;
|
||||
let mut layer_node = hash_value(&value);
|
||||
let mut layer_index = new_index + base_length - 1;
|
||||
self.set_node(layer_index, layer_node);
|
||||
let mut node_index = new_index + self.capacity - 1;
|
||||
let mut node_hash = hash_value(&value);
|
||||
|
||||
let mut layer = 0;
|
||||
let mut top_layer = self.depth();
|
||||
while layer < top_layer {
|
||||
let is_left_child = layer_index & 1 == 1;
|
||||
self.set_node(node_index, node_hash);
|
||||
self.length += 1;
|
||||
|
||||
let (parent_index, new_parent_node) = if is_left_child {
|
||||
let parent_index = (layer_index - 1) >> 1;
|
||||
let sibling = self.get_node(&(layer_index + 1));
|
||||
let new_parent_node = hash_two(&layer_node, sibling);
|
||||
(parent_index, new_parent_node)
|
||||
} else {
|
||||
let parent_index = (layer_index - 2) >> 1;
|
||||
let sibling = self.get_node(&(layer_index - 1));
|
||||
let new_parent_node = hash_two(sibling, &layer_node);
|
||||
(parent_index, new_parent_node)
|
||||
};
|
||||
|
||||
self.set_node(parent_index, new_parent_node);
|
||||
|
||||
layer += 1;
|
||||
layer_index = parent_index;
|
||||
layer_node = new_parent_node
|
||||
let root_index = self.root_index();
|
||||
for _ in 0..self.depth() {
|
||||
let parent_index = (node_index - 1) >> 1;
|
||||
let left_child = self.get_node((parent_index << 1) + 1);
|
||||
let right_child = self.get_node((parent_index << 1) + 2);
|
||||
node_hash = hash_two(left_child, right_child);
|
||||
self.set_node(parent_index, node_hash);
|
||||
node_index = parent_index;
|
||||
}
|
||||
|
||||
true
|
||||
new_index
|
||||
}
|
||||
|
||||
pub fn new(values: &[Value]) -> Self {
|
||||
let mut deduplicated_values: Vec<Value> = Vec::with_capacity(values.len());
|
||||
let mut seen = HashSet::new();
|
||||
for value in values.into_iter() {
|
||||
if !seen.contains(value) {
|
||||
deduplicated_values.push(*value);
|
||||
seen.insert(*value);
|
||||
}
|
||||
}
|
||||
let mut this = Self::with_capacity(deduplicated_values.len());
|
||||
for value in deduplicated_values.into_iter() {
|
||||
let mut this = Self::with_capacity(values.len());
|
||||
for value in values.iter().cloned() {
|
||||
this.insert(value);
|
||||
}
|
||||
this
|
||||
}
|
||||
|
||||
pub fn get_authentication_path_for(&self, value: &Value) -> Option<(usize, Vec<Node>)> {
|
||||
let mut result = Vec::with_capacity(self.depth());
|
||||
let value_index = self.index_map.get(value)?;
|
||||
let base_length = self.capacity;
|
||||
let mut layer_index = base_length + value_index - 1;
|
||||
let mut layer = 0;
|
||||
let top_layer = self.depth();
|
||||
while layer < top_layer {
|
||||
let is_left_child = layer_index & 1 == 1;
|
||||
let (sibling, parent_index) = if is_left_child {
|
||||
(self.get_node(&(layer_index + 1)), (layer_index - 1) >> 1)
|
||||
pub fn get_authentication_path_for(&self, index: usize) -> Option<Vec<Node>> {
|
||||
if index >= self.length {
|
||||
return None;
|
||||
}
|
||||
|
||||
let mut path = Vec::with_capacity(self.depth());
|
||||
|
||||
let mut node_index = self.capacity + index - 1;
|
||||
let root_index = self.root_index();
|
||||
|
||||
while node_index != root_index {
|
||||
let parent_index = (node_index - 1) >> 1;
|
||||
let is_left_child = node_index & 1 == 1;
|
||||
let sibling_index = if is_left_child {
|
||||
node_index + 1
|
||||
} else {
|
||||
(self.get_node(&(layer_index - 1)), (layer_index - 2) >> 1)
|
||||
node_index - 1
|
||||
};
|
||||
result.push(*sibling);
|
||||
|
||||
layer += 1;
|
||||
layer_index = parent_index;
|
||||
}
|
||||
Some((*value_index, result))
|
||||
path.push(*self.get_node(sibling_index));
|
||||
node_index = parent_index;
|
||||
}
|
||||
|
||||
pub(crate) fn contains(&self, value: &[u8; 32]) -> bool {
|
||||
self.index_map.contains_key(value)
|
||||
Some(path)
|
||||
}
|
||||
}
|
||||
|
||||
@ -183,26 +171,34 @@ fn verify_authentication_path(value: &Value, index: usize, path: &[Node], root:
|
||||
&result == root
|
||||
}
|
||||
|
||||
fn prev_power_of_two(x: usize) -> usize {
|
||||
if x == 0 {
|
||||
return 0; // define as 0
|
||||
}
|
||||
1 << (usize::BITS as usize - x.leading_zeros() as usize - 1)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use hex_literal::hex;
|
||||
use nssa_core::account::{Account, NullifierPublicKey};
|
||||
|
||||
use super::*;
|
||||
#[test]
|
||||
fn test_merkle_tree_0() {
|
||||
let values = [[0; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = assert_eq!(tree.length, 1);
|
||||
assert_eq!(tree.root(), hash_value(&[0; 32]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_merkle_tree_1() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = [
|
||||
72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170, 32, 207,
|
||||
20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
|
||||
];
|
||||
|
||||
let expected_root =
|
||||
hex!("48c73f7821a58a8d2a703e5b39c571c0aa20cf14abcd0af8f2b955bc202998de");
|
||||
assert_eq!(tree.root(), expected_root);
|
||||
assert_eq!(*tree.index_map.get(&[1; 32]).unwrap(), 0);
|
||||
assert_eq!(*tree.index_map.get(&[2; 32]).unwrap(), 1);
|
||||
assert_eq!(*tree.index_map.get(&[3; 32]).unwrap(), 2);
|
||||
assert_eq!(*tree.index_map.get(&[4; 32]).unwrap(), 3);
|
||||
assert_eq!(tree.capacity, 4);
|
||||
}
|
||||
|
||||
@ -210,16 +206,9 @@ mod tests {
|
||||
fn test_merkle_tree_2() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [0; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = [
|
||||
201, 187, 184, 48, 150, 223, 133, 21, 122, 20, 110, 125, 119, 4, 85, 169, 132, 18, 222,
|
||||
224, 99, 49, 135, 238, 134, 254, 230, 200, 164, 91, 131, 26,
|
||||
];
|
||||
|
||||
let expected_root =
|
||||
hex!("c9bbb83096df85157a146e7d770455a98412dee0633187ee86fee6c8a45b831a");
|
||||
assert_eq!(tree.root(), expected_root);
|
||||
assert_eq!(*tree.index_map.get(&[1; 32]).unwrap(), 0);
|
||||
assert_eq!(*tree.index_map.get(&[2; 32]).unwrap(), 1);
|
||||
assert_eq!(*tree.index_map.get(&[3; 32]).unwrap(), 2);
|
||||
assert_eq!(*tree.index_map.get(&[0; 32]).unwrap(), 3);
|
||||
assert_eq!(tree.capacity, 4);
|
||||
}
|
||||
|
||||
@ -227,16 +216,9 @@ mod tests {
|
||||
fn test_merkle_tree_3() {
|
||||
let values = [[1; 32], [2; 32], [3; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = [
|
||||
200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
|
||||
167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
|
||||
];
|
||||
|
||||
let expected_root =
|
||||
hex!("c8d3d8d2b13f27ceeccdc699119871f9f32ea7ed86ff45d0ad11f77b28cd7568");
|
||||
assert_eq!(tree.root(), expected_root);
|
||||
assert_eq!(*tree.index_map.get(&[1; 32]).unwrap(), 0);
|
||||
assert_eq!(*tree.index_map.get(&[2; 32]).unwrap(), 1);
|
||||
assert_eq!(*tree.index_map.get(&[3; 32]).unwrap(), 2);
|
||||
assert!(tree.index_map.get(&[0; 32]).is_none());
|
||||
assert_eq!(tree.capacity, 4);
|
||||
}
|
||||
|
||||
@ -244,17 +226,10 @@ mod tests {
|
||||
fn test_merkle_tree_4() {
|
||||
let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = [
|
||||
239, 65, 138, 237, 90, 162, 7, 2, 212, 217, 76, 146, 218, 121, 164, 1, 47, 46, 54, 241,
|
||||
0, 139, 253, 179, 205, 30, 56, 116, 157, 202, 36, 153,
|
||||
];
|
||||
let expected_root =
|
||||
hex!("ef418aed5aa20702d4d94c92da79a4012f2e36f1008bfdb3cd1e38749dca2499");
|
||||
|
||||
assert_eq!(tree.root(), expected_root);
|
||||
assert_eq!(*tree.index_map.get(&[11; 32]).unwrap(), 0);
|
||||
assert_eq!(*tree.index_map.get(&[12; 32]).unwrap(), 1);
|
||||
assert_eq!(*tree.index_map.get(&[13; 32]).unwrap(), 2);
|
||||
assert_eq!(*tree.index_map.get(&[14; 32]).unwrap(), 3);
|
||||
assert_eq!(*tree.index_map.get(&[15; 32]).unwrap(), 4);
|
||||
assert_eq!(tree.capacity, 8);
|
||||
}
|
||||
|
||||
@ -265,17 +240,9 @@ mod tests {
|
||||
[13; 32], [15; 32], [11; 32],
|
||||
];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = [
|
||||
239, 65, 138, 237, 90, 162, 7, 2, 212, 217, 76, 146, 218, 121, 164, 1, 47, 46, 54, 241,
|
||||
0, 139, 253, 179, 205, 30, 56, 116, 157, 202, 36, 153,
|
||||
];
|
||||
|
||||
let expected_root =
|
||||
hex!("ef418aed5aa20702d4d94c92da79a4012f2e36f1008bfdb3cd1e38749dca2499");
|
||||
assert_eq!(tree.root(), expected_root);
|
||||
assert_eq!(*tree.index_map.get(&[11; 32]).unwrap(), 0);
|
||||
assert_eq!(*tree.index_map.get(&[12; 32]).unwrap(), 1);
|
||||
assert_eq!(*tree.index_map.get(&[13; 32]).unwrap(), 2);
|
||||
assert_eq!(*tree.index_map.get(&[14; 32]).unwrap(), 3);
|
||||
assert_eq!(*tree.index_map.get(&[15; 32]).unwrap(), 4);
|
||||
assert_eq!(tree.capacity, 8);
|
||||
}
|
||||
|
||||
@ -283,11 +250,8 @@ mod tests {
|
||||
fn test_merkle_tree_6() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_root = [
|
||||
6, 156, 184, 37, 154, 6, 254, 110, 219, 63, 167, 255, 121, 51, 166, 221, 125, 202, 111,
|
||||
202, 41, 147, 20, 55, 151, 148, 166, 136, 146, 108, 55, 146,
|
||||
];
|
||||
|
||||
let expected_root =
|
||||
hex!("069cb8259a06fe6edb3fa7ff7933a6dd7dca6fca299314379794a688926c3792");
|
||||
assert_eq!(tree.root(), expected_root);
|
||||
}
|
||||
|
||||
@ -295,33 +259,33 @@ mod tests {
|
||||
fn test_with_capacity_4() {
|
||||
let tree = MerkleTree::with_capacity(4);
|
||||
|
||||
assert!(tree.index_map.is_empty());
|
||||
assert!(tree.node_map.is_empty());
|
||||
assert_eq!(tree.length, 0);
|
||||
assert_eq!(tree.nodes.len(), 7);
|
||||
for i in 3..7 {
|
||||
assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[0], "{i}");
|
||||
assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[0], "{i}");
|
||||
}
|
||||
for i in 1..3 {
|
||||
assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[1], "{i}");
|
||||
assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[1], "{i}");
|
||||
}
|
||||
assert_eq!(*tree.get_node(&0), default_values::DEFAULT_VALUES[2]);
|
||||
assert_eq!(*tree.get_node(0), default_values::DEFAULT_VALUES[2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_with_capacity_5() {
|
||||
let tree = MerkleTree::with_capacity(5);
|
||||
|
||||
assert!(tree.index_map.is_empty());
|
||||
assert!(tree.node_map.is_empty());
|
||||
assert_eq!(tree.length, 0);
|
||||
assert_eq!(tree.nodes.len(), 15);
|
||||
for i in 7..15 {
|
||||
assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[0])
|
||||
assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[0])
|
||||
}
|
||||
for i in 3..7 {
|
||||
assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[1])
|
||||
assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[1])
|
||||
}
|
||||
for i in 1..3 {
|
||||
assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[2])
|
||||
assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[2])
|
||||
}
|
||||
assert_eq!(*tree.get_node(&0), default_values::DEFAULT_VALUES[3])
|
||||
assert_eq!(*tree.get_node(0), default_values::DEFAULT_VALUES[3])
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -330,10 +294,8 @@ mod tests {
|
||||
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
|
||||
|
||||
let expected_root = [
|
||||
72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170, 32, 207,
|
||||
20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
|
||||
];
|
||||
let expected_root =
|
||||
hex!("48c73f7821a58a8d2a703e5b39c571c0aa20cf14abcd0af8f2b955bc202998de");
|
||||
|
||||
tree.insert(values[0]);
|
||||
tree.insert(values[1]);
|
||||
@ -349,10 +311,8 @@ mod tests {
|
||||
|
||||
let values = [[1; 32], [2; 32], [3; 32]];
|
||||
|
||||
let expected_root = [
|
||||
200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
|
||||
167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
|
||||
];
|
||||
let expected_root =
|
||||
hex!("c8d3d8d2b13f27ceeccdc699119871f9f32ea7ed86ff45d0ad11f77b28cd7568");
|
||||
|
||||
tree.insert(values[0]);
|
||||
tree.insert(values[1]);
|
||||
@ -367,10 +327,8 @@ mod tests {
|
||||
|
||||
let values = [[1; 32], [2; 32], [3; 32]];
|
||||
|
||||
let expected_root = [
|
||||
200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
|
||||
167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
|
||||
];
|
||||
let expected_root =
|
||||
hex!("c8d3d8d2b13f27ceeccdc699119871f9f32ea7ed86ff45d0ad11f77b28cd7568");
|
||||
|
||||
tree.insert(values[0]);
|
||||
tree.insert(values[1]);
|
||||
@ -424,47 +382,16 @@ mod tests {
|
||||
assert_eq!(expected_tree, tree);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_insert_value_4() {
|
||||
let mut tree = MerkleTree::with_capacity(1);
|
||||
|
||||
let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
|
||||
let expected_tree = MerkleTree::new(&values);
|
||||
|
||||
tree.insert(values[0]);
|
||||
tree.insert(values[0]);
|
||||
tree.insert(values[1]);
|
||||
tree.insert(values[1]);
|
||||
tree.insert(values[2]);
|
||||
tree.insert(values[3]);
|
||||
tree.insert(values[2]);
|
||||
tree.insert(values[0]);
|
||||
tree.insert(values[4]);
|
||||
tree.insert(values[2]);
|
||||
tree.insert(values[4]);
|
||||
|
||||
assert_eq!(expected_tree, tree);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_authentication_path_1() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_authentication_path = (
|
||||
2,
|
||||
vec![
|
||||
[
|
||||
159, 79, 182, 143, 62, 29, 172, 130, 32, 47, 154, 165, 129, 206, 11, 191, 31,
|
||||
118, 93, 240, 233, 172, 60, 140, 87, 226, 15, 104, 90, 186, 184, 237,
|
||||
],
|
||||
[
|
||||
80, 162, 125, 71, 70, 243, 87, 203, 112, 12, 190, 157, 72, 131, 183, 127, 182,
|
||||
79, 1, 40, 130, 138, 52, 137, 220, 106, 111, 33, 221, 191, 36, 20,
|
||||
],
|
||||
],
|
||||
);
|
||||
let expected_authentication_path = vec![
|
||||
hex!("9f4fb68f3e1dac82202f9aa581ce0bbf1f765df0e9ac3c8c57e20f685abab8ed"),
|
||||
hex!("50a27d4746f357cb700cbe9d4883b77fb64f0128828a3489dc6a6f21ddbf2414"),
|
||||
];
|
||||
|
||||
let authentication_path = tree.get_authentication_path_for(&[3; 32]).unwrap();
|
||||
let authentication_path = tree.get_authentication_path_for(2).unwrap();
|
||||
assert_eq!(authentication_path, expected_authentication_path);
|
||||
}
|
||||
|
||||
@ -472,21 +399,12 @@ mod tests {
|
||||
fn test_authentication_path_2() {
|
||||
let values = [[1; 32], [2; 32], [3; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_authentication_path = (
|
||||
0,
|
||||
vec![
|
||||
[
|
||||
117, 135, 123, 180, 29, 57, 59, 95, 184, 69, 92, 230, 14, 205, 141, 218, 0, 29,
|
||||
6, 49, 100, 150, 177, 77, 250, 127, 137, 86, 86, 238, 202, 74,
|
||||
],
|
||||
[
|
||||
164, 27, 133, 93, 45, 180, 222, 144, 82, 205, 123, 229, 236, 103, 214, 88, 102,
|
||||
41, 203, 159, 110, 50, 70, 164, 175, 165, 186, 49, 63, 7, 169, 197,
|
||||
],
|
||||
],
|
||||
);
|
||||
let expected_authentication_path = vec![
|
||||
hex!("75877bb41d393b5fb8455ce60ecd8dda001d06316496b14dfa7f895656eeca4a"),
|
||||
hex!("a41b855d2db4de9052cd7be5ec67d6586629cb9f6e3246a4afa5ba313f07a9c5"),
|
||||
];
|
||||
|
||||
let authentication_path = tree.get_authentication_path_for(&[1; 32]).unwrap();
|
||||
let authentication_path = tree.get_authentication_path_for(0).unwrap();
|
||||
assert_eq!(authentication_path, expected_authentication_path);
|
||||
}
|
||||
|
||||
@ -494,25 +412,13 @@ mod tests {
|
||||
fn test_authentication_path_3() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let expected_authentication_path = (
|
||||
4,
|
||||
vec![
|
||||
[
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0,
|
||||
],
|
||||
[
|
||||
245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67,
|
||||
0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169, 39, 89, 251, 75,
|
||||
],
|
||||
[
|
||||
72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170,
|
||||
32, 207, 20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
|
||||
],
|
||||
],
|
||||
);
|
||||
let expected_authentication_path = vec![
|
||||
hex!("0000000000000000000000000000000000000000000000000000000000000000"),
|
||||
hex!("f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b"),
|
||||
hex!("48c73f7821a58a8d2a703e5b39c571c0aa20cf14abcd0af8f2b955bc202998de"),
|
||||
];
|
||||
|
||||
let authentication_path = tree.get_authentication_path_for(&[5; 32]).unwrap();
|
||||
let authentication_path = tree.get_authentication_path_for(4).unwrap();
|
||||
assert_eq!(authentication_path, expected_authentication_path);
|
||||
}
|
||||
|
||||
@ -520,24 +426,16 @@ mod tests {
|
||||
fn test_authentication_path_4() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let value = [6; 32];
|
||||
assert!(tree.get_authentication_path_for(&value).is_none());
|
||||
assert!(tree.get_authentication_path_for(5).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_authentication_path_5() {
|
||||
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let value = [0; 32];
|
||||
assert!(tree.get_authentication_path_for(&value).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_authentication_path_6() {
|
||||
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
|
||||
let tree = MerkleTree::new(&values);
|
||||
let value = [5; 32];
|
||||
let (index, path) = tree.get_authentication_path_for(&value).unwrap();
|
||||
let index = 4;
|
||||
let value = values[index];
|
||||
let path = tree.get_authentication_path_for(index).unwrap();
|
||||
assert!(verify_authentication_path(
|
||||
&value,
|
||||
index,
|
||||
@ -545,6 +443,92 @@ mod tests {
|
||||
&tree.root()
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tree_with_63_insertions() {
|
||||
let values = [
|
||||
hex!("cd00acab0f45736e6c6311f1953becc0b69a062e7c2a7310875d28bdf9ef9c5b"),
|
||||
hex!("0df5a6afbcc7bf126caf7084acfc593593ab512e6ca433c61c1a922be40a04ea"),
|
||||
hex!("23c1258620266c7bedb6d1ee32f6da9413e4010ace975239dccb34e727e07c40"),
|
||||
hex!("f33ccc3a11476b0ef62326ca5ec292056759b05e6a28023d2d1ce66165611353"),
|
||||
hex!("77f914ab016b8049f6bea7704000e413a393865918a3824f9285c3db0aacff23"),
|
||||
hex!("910a1c23188e54d57fd167ddb0f8bf68c6b70ed9ec76ef56c4b7f2632f82ca7f"),
|
||||
hex!("047ee85526197d1e7403a559cf6d2f22c1926c8ad59481a2e2f1b697af45e40b"),
|
||||
hex!("9d355cf89fb382ae34bf80566b28489278d10f2cebb5b0ea42fab1bac5adae0c"),
|
||||
hex!("604018b95232596b2685a9bc737b6cccb53b10e483d2d9a2f4a755410b02a188"),
|
||||
hex!("a16708ef7b6bf1796063addaf57d6a566b6f87b0bbe42af43a4590d05f1684cb"),
|
||||
hex!("820f2dfa271cd2fd41e1452406d5dad552c85c1223c45d45dbd7446759fdc6b8"),
|
||||
hex!("680b6912d7e219f8805d4d28adb4428dd78fea0dc1b8cdb2412645c4b1962c88"),
|
||||
hex!("14d5471ce6c45506753982b17cac5790ac7bc29e6f388f31052d7dfd62b294e5"),
|
||||
hex!("8b364200172b777d4aa16d2098b5eb98ac3dd4a1b9597e5c2bf6f6930031f230"),
|
||||
hex!("9bb45b910711874339dda8a21a9aad73822286f5e52d7d3de0ed78dfbba329a5"),
|
||||
hex!("d6806d5df5cb25ce5d531042f09b3cb34fb9e47c61182b63cccd9d44392f6027"),
|
||||
hex!("b8cfa90ebc8fd09c04682d93a08fddd3e8e57715174dcc92451edd191264a58b"),
|
||||
hex!("3463c7f81d00f809b3dfa83195447c927fb4045b3913dac6f45bee6c4010d7ed"),
|
||||
hex!("1d6ad7f7d677905feb506c58f4b404a79370ebc567296abea3a368b61d5a8239"),
|
||||
hex!("a58085ecf00963cb22da23c901b9b3ddc56462bb96ff03c923d67708e10dd29c"),
|
||||
hex!("c3319f4a65fb5bbb8447137b0972c03cbd84ebf7d9da194e0fcbd68c2d4d5bdb"),
|
||||
hex!("4aa31e90e0090faf3648d05e5d5499df2c78ebed4d6e6c23d8147de5d67dae73"),
|
||||
hex!("9f33b1d2c8bc7bd265336de1033ede6344bc41260313bdcb43f1108b83b9be92"),
|
||||
hex!("6500d4ad93d41c16ec81eaa5e70f173194aabe5c1072ac263b5727296f5b7cac"),
|
||||
hex!("3584f5d260003669fad98786e13171376b0f19410cb232ce65606cbff79e6768"),
|
||||
hex!("c8410946ebf56f13141c894a34ced85a5230088af70dcea581e44f52847830ac"),
|
||||
hex!("71dd90281cdebb70422f2d04ae446d5d2d5ea64b803c16128d37e3fcd5d1a4cc"),
|
||||
hex!("c05acf8d77ab4d659a538bd35af590864a7ad9c055ff5d6cda9d5aecfccecba3"),
|
||||
hex!("f1df98822ea084cce9021aa9cc81b1746cd1e84a75690da63e10fd877633ed77"),
|
||||
hex!("2ca822bc8f67bceb0a71a0d06fea7349036ef3e5ec21795a851e4182bd35ce01"),
|
||||
hex!("7fd2179abc3bcf89b4d8092988ba8c23952b3bbd3d7caea6b5ea0c13cf19f68b"),
|
||||
hex!("91b6ad516e017f6aa5a2e95776538bd3a3e933c1b1d32bb5e0f00a9db63c9c24"),
|
||||
hex!("cd31a8b5eef5ca0be5ef1cb261d0bf0a74d774a3152bb99739cfd296a1d0b85e"),
|
||||
hex!("3fb16f48b2bf93f3815979e6638f975d7f935088ec37db0be0f07965fbc78339"),
|
||||
hex!("c60c61b99bf486af5f4bf780a69860dafcd35c1474306a8575666fb5449bcec0"),
|
||||
hex!("8048d0d7e14091251f3f6c6b10bf6b5880a014b513f9f8c2395501dbffa6192a"),
|
||||
hex!("778b5af10b9dbe80b60a8e4f0bb91caf4476bcb812801099760754ae623fbd84"),
|
||||
hex!("d3ac25467920a4e08998b7a3226b8b54bfe66ac58cfedc71f15b2402fee0054a"),
|
||||
hex!("029aa94598fae2961a0d43937b8a9a3138bcfeae99a7cb15f77fac7c506f8432"),
|
||||
hex!("2eee5ef52fe669cb6882a68c893abdc1262dcf4424e4ba7a479da7cf1c10171d"),
|
||||
hex!("de3fb3d070e3a90f0eed8b5e65088a8dc0e4e3c342b9c0bf33bab714eae5dfec"),
|
||||
hex!("14d40177e833ab45bbfdc5f2b11fba7efaebb3f69facc554f24b549a2efe8538"),
|
||||
hex!("5734355069702448774fb2df95f1d562e1b9fe1514aeb6b922554ee9d2d01068"),
|
||||
hex!("8a273d49ac110343cec2cf3359d16eb2906b446bd9ec9833e2a640cebc8d5155"),
|
||||
hex!("e3fa984dd3cbeb9a7e827ed32d3d4e6a6ba643a55d82be97d9ddb06ee809fa3e"),
|
||||
hex!("90b1d5a364e17c8b7965396b06ec6e13749b5fc16500731518ad8fc30ae33e77"),
|
||||
hex!("7517376541b2e8ec83cbab04522b54a26610908a9872feb663451385aea58eb1"),
|
||||
hex!("5cba2e4cf7448e526d161133c4b2ea7c919ac4813a7308612595f46f11dea6cd"),
|
||||
hex!("c721911b300bec0691c8a2dfaabfef1d66b7b6258918914d3c3ad690729f05b7"),
|
||||
hex!("d0d0a70d8ae0d27806fa0b711c507290c260a89cbca0436d339d1dccdd087d62"),
|
||||
hex!("2a625c28ea763c5e82dd0a93ecfca7ec371ccbb363cd42be359c2c875f58009d"),
|
||||
hex!("174ef0119932ed890397d9f3837dd85f9100558b6fc9085d4af947ae8cf74bbc"),
|
||||
hex!("b497bc267151e8efa3c6daa461e6804b01a3f05f44f1f4d5b41d5f0d3f5219b1"),
|
||||
hex!("e987e91f5734630ddd7e6b58733b4fcdbc316ee9e8cac0e94c36c91cf58e59cc"),
|
||||
hex!("55019ad8bbe656c51eb042190c1c8da53f42baf43fd2350ebea38fc7cca2fae3"),
|
||||
hex!("c45a638edd18a6d9f5ad20b870c81b8626459bcb22dae7d58add7a6b6c6a84a8"),
|
||||
hex!("d42d3a5fb2ad50b2027fe5a36d59dd71e49a63e4b1b299073c96bbf7ba5d68a1"),
|
||||
hex!("9599e561054bcd3f647eb018ab0b069d3176497d42be9c4466551cbb959be47c"),
|
||||
hex!("42f33b23775327ff71aea6569548255f3cc9929da73373cc9bb1743d417f7cda"),
|
||||
hex!("ab24294f44fc6fdbeb96e0f6e93c4f6d97d035b73b9a337c353e18c6d0603bdd"),
|
||||
hex!("33954ec63520334f99b640a2982ac966b68c363fed383d621a1ab573934f1d33"),
|
||||
hex!("5e2a1f7df963d1fd8f50a285387cfbb5df581426619b325563e20bf7886c62b7"),
|
||||
hex!("13ffde471d4e27c473254e766fd1328ad80c42cab4d4955cffeae43d866f86e5"),
|
||||
];
|
||||
|
||||
let expected_root =
|
||||
hex!("1cf9b214217d7823f9de51b8f6cb34d0a99436a3a1bb762f90b815672a6afcc0");
|
||||
|
||||
let mut tree_less_capacity = MerkleTree::with_capacity(1);
|
||||
let mut tree_exact_capacity = MerkleTree::with_capacity(64);
|
||||
let mut tree_more_capacity = MerkleTree::with_capacity(128);
|
||||
|
||||
for value in &values {
|
||||
tree_less_capacity.insert(*value);
|
||||
tree_exact_capacity.insert(*value);
|
||||
tree_more_capacity.insert(*value);
|
||||
}
|
||||
|
||||
assert_eq!(tree_more_capacity.root(), expected_root);
|
||||
assert_eq!(tree_less_capacity.root(), expected_root);
|
||||
assert_eq!(tree_exact_capacity.root(), expected_root);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
@ -192,13 +192,15 @@ mod tests {
|
||||
let sender_keys = test_private_account_keys_1();
|
||||
let recipient_keys = test_private_account_keys_2();
|
||||
let commitment_sender = Commitment::new(&sender_keys.npk(), &sender_pre.account);
|
||||
|
||||
let recipient = AccountWithMetadata {
|
||||
account: Account::default(),
|
||||
is_authorized: false,
|
||||
};
|
||||
let balance_to_move: u128 = 37;
|
||||
|
||||
let commitment_set = CommitmentSet(MerkleTree::new(&[commitment_sender.to_byte_array()]));
|
||||
let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &sender_keys.nsk)];
|
||||
|
||||
let program = Program::authenticated_transfer_program();
|
||||
|
||||
let expected_private_account_1 = Account {
|
||||
@ -217,7 +219,9 @@ mod tests {
|
||||
Commitment::new(&sender_keys.npk(), &expected_private_account_1),
|
||||
Commitment::new(&recipient_keys.npk(), &expected_private_account_2),
|
||||
];
|
||||
let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &sender_keys.nsk)];
|
||||
|
||||
let mut commitment_set = CommitmentSet::with_capacity(2);
|
||||
commitment_set.extend(&[commitment_sender.clone()]);
|
||||
|
||||
let (output, proof) = execute_and_prove(
|
||||
&[sender_pre.clone(), recipient],
|
||||
|
||||
@ -10,26 +10,39 @@ use nssa_core::{
|
||||
};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
pub(crate) struct CommitmentSet(pub(crate) MerkleTree);
|
||||
pub(crate) struct CommitmentSet {
|
||||
merkle_tree: MerkleTree,
|
||||
commitments: HashMap<Commitment, usize>,
|
||||
}
|
||||
|
||||
impl CommitmentSet {
|
||||
pub(crate) fn digest(&self) -> CommitmentSetDigest {
|
||||
self.0.root()
|
||||
self.merkle_tree.root()
|
||||
}
|
||||
|
||||
pub(crate) fn get_proof_for(&self, commitment: &Commitment) -> Option<MembershipProof> {
|
||||
self.0
|
||||
.get_authentication_path_for(&commitment.to_byte_array())
|
||||
let index = *self.commitments.get(commitment)?;
|
||||
self.merkle_tree
|
||||
.get_authentication_path_for(index)
|
||||
.map(|path| (index, path))
|
||||
}
|
||||
|
||||
pub(crate) fn extend(&mut self, commitments: &[Commitment]) {
|
||||
for commitment in commitments {
|
||||
self.0.insert(commitment.to_byte_array());
|
||||
for commitment in commitments.iter().cloned() {
|
||||
let index = self.merkle_tree.insert(commitment.to_byte_array());
|
||||
self.commitments.insert(commitment, index);
|
||||
}
|
||||
}
|
||||
|
||||
fn contains(&self, commitment: &Commitment) -> bool {
|
||||
self.0.contains(&commitment.to_byte_array())
|
||||
self.commitments.contains_key(commitment)
|
||||
}
|
||||
|
||||
pub(crate) fn with_capacity(capacity: usize) -> CommitmentSet {
|
||||
Self {
|
||||
merkle_tree: MerkleTree::with_capacity(capacity),
|
||||
commitments: HashMap::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -59,10 +72,7 @@ impl V01State {
|
||||
|
||||
let mut this = Self {
|
||||
public_state,
|
||||
private_state: (
|
||||
CommitmentSet(MerkleTree::with_capacity(32)),
|
||||
NullifierSet::new(),
|
||||
),
|
||||
private_state: (CommitmentSet::with_capacity(32), NullifierSet::new()),
|
||||
builtin_programs: HashMap::new(),
|
||||
};
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user