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

use std_shims::vec::Vec;

use crate::primitives::keccak256;

pub(crate) fn merkle_root(root: [u8; 32], leafs: &[[u8; 32]]) -> [u8; 32] {
  match leafs.len() {
    0 => root,
    1 => keccak256([root, leafs[0]].concat()),
    _ => {
      let mut hashes = Vec::with_capacity(1 + leafs.len());
      hashes.push(root);
      hashes.extend(leafs);

      // Monero preprocess this so the length is a power of 2
      let mut high_pow_2 = 4; // 4 is the lowest value this can be
      while high_pow_2 < hashes.len() {
        high_pow_2 *= 2;
      }
      let low_pow_2 = high_pow_2 / 2;

      // Merge right-most hashes until we're at the low_pow_2
      {
        let overage = hashes.len() - low_pow_2;
        let mut rightmost = hashes.drain((low_pow_2 - overage) ..);
        // This is true since we took overage from beneath and above low_pow_2, taking twice as
        // many elements as overage
        debug_assert_eq!(rightmost.len() % 2, 0);

        let mut paired_hashes = Vec::with_capacity(overage);
        while let Some(left) = rightmost.next() {
          let right = rightmost.next().unwrap();
          paired_hashes.push(keccak256([left.as_ref(), &right].concat()));
        }
        drop(rightmost);

        hashes.extend(paired_hashes);
        assert_eq!(hashes.len(), low_pow_2);
      }

      // Do a traditional pairing off
      let mut new_hashes = Vec::with_capacity(hashes.len() / 2);
      while hashes.len() > 1 {
        let mut i = 0;
        while i < hashes.len() {
          new_hashes.push(keccak256([hashes[i], hashes[i + 1]].concat()));
          i += 2;
        }

        hashes = new_hashes;
        new_hashes = Vec::with_capacity(hashes.len() / 2);
      }
      hashes[0]
    }
  }
}