// merkletree.rs implements a simple binary insert-only merkletree in which the leafs positions is
|
|
// determined by the leaf value binary representation. Inspired by
|
|
// https://docs.iden3.io/publications/pdfs/Merkle-Tree.pdf (which can be found implemented in
|
|
// https://github.com/vocdoni/arbo).
|
|
|
|
use ark_ff::{BigInteger, PrimeField};
|
|
use ark_serialize::CanonicalSerialize;
|
|
use ark_std::log2;
|
|
use ark_std::marker::PhantomData;
|
|
use sha3::{Digest, Keccak256};
|
|
|
|
// abstraction to set the hash function used
|
|
pub trait Hash<F>: Clone {
|
|
fn hash(_in: &[F]) -> F;
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct Keccak256Hash<F: PrimeField> {
|
|
phantom: PhantomData<F>,
|
|
}
|
|
impl<F: PrimeField> Hash<F> for Keccak256Hash<F> {
|
|
fn hash(_in: &[F]) -> F {
|
|
let mut buf = vec![];
|
|
_in.serialize_uncompressed(&mut buf).unwrap();
|
|
|
|
let mut h = Keccak256::default();
|
|
h.update(buf);
|
|
let r = h.finalize();
|
|
let out = F::from_le_bytes_mod_order(&r);
|
|
out
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Node<F: PrimeField, H: Hash<F>> {
|
|
phantom: PhantomData<H>,
|
|
hash: F,
|
|
left: Option<Box<Node<F, H>>>,
|
|
right: Option<Box<Node<F, H>>>,
|
|
value: Option<F>,
|
|
}
|
|
|
|
impl<F: PrimeField, H: Hash<F>> Node<F, H> {
|
|
pub fn new_leaf(v: F) -> Self {
|
|
let h = H::hash(&[v]);
|
|
Self {
|
|
phantom: PhantomData::<H>,
|
|
hash: h,
|
|
left: None,
|
|
right: None,
|
|
value: Some(v),
|
|
}
|
|
}
|
|
pub fn new_node(l: Self, r: Self) -> Self {
|
|
let left = Box::new(l);
|
|
let right = Box::new(r);
|
|
let hash = H::hash(&[left.hash, right.hash]);
|
|
Self {
|
|
phantom: PhantomData::<H>,
|
|
hash,
|
|
left: Some(left),
|
|
right: Some(right),
|
|
value: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct MerkleTree<F: PrimeField, H: Hash<F>> {
|
|
pub root: Node<F, H>,
|
|
nlevels: u32,
|
|
}
|
|
|
|
impl<F: PrimeField, H: Hash<F>> MerkleTree<F, H> {
|
|
pub fn commit(values: &[F]) -> (F, Self) {
|
|
// for the moment assume that values length is a power of 2.
|
|
if (values.len() != 0) && (values.len() & (values.len() - 1) != 0) {
|
|
panic!("values.len() should be a power of 2");
|
|
}
|
|
|
|
// prepare the leafs
|
|
let mut leaf_nodes: Vec<Node<F, H>> = Vec::new();
|
|
for i in 0..values.len() {
|
|
let node = Node::<F, H>::new_leaf(values[i]);
|
|
leaf_nodes.push(node);
|
|
}
|
|
// go up from the leafs to the root
|
|
let top_nodes = Self::up_from_nodes(leaf_nodes);
|
|
|
|
(
|
|
top_nodes[0].hash,
|
|
Self {
|
|
root: top_nodes[0].clone(),
|
|
nlevels: log2(values.len()),
|
|
},
|
|
)
|
|
}
|
|
fn up_from_nodes(nodes: Vec<Node<F, H>>) -> Vec<Node<F, H>> {
|
|
if nodes.len() == 0 {
|
|
return [Node::<F, H> {
|
|
phantom: PhantomData::<H>,
|
|
hash: F::from(0_u32),
|
|
left: None,
|
|
right: None,
|
|
value: None,
|
|
}]
|
|
.to_vec();
|
|
}
|
|
if nodes.len() == 1 {
|
|
return nodes;
|
|
}
|
|
let mut next_level_nodes: Vec<Node<F, H>> = Vec::new();
|
|
for i in (0..nodes.len()).step_by(2) {
|
|
let node = Node::<F, H>::new_node(nodes[i].clone(), nodes[i + 1].clone());
|
|
next_level_nodes.push(node);
|
|
}
|
|
return Self::up_from_nodes(next_level_nodes);
|
|
}
|
|
fn get_path(num_levels: u32, value: F) -> Vec<bool> {
|
|
let value_bytes = value.into_bigint().to_bytes_le();
|
|
let mut path = Vec::new();
|
|
for i in 0..num_levels {
|
|
path.push(value_bytes[(i / 8) as usize] & (1 << (i % 8)) != 0);
|
|
}
|
|
path
|
|
}
|
|
pub fn open(&self, index: F) -> Vec<F> {
|
|
// start from root, and go down to the index, while getting the siblings at each level
|
|
let path = Self::get_path(self.nlevels, index);
|
|
// reverse path as we're going from up to down
|
|
let path_inv = path.iter().copied().rev().collect();
|
|
let mut siblings: Vec<F> = Vec::new();
|
|
siblings = Self::go_down(path_inv, self.root.clone(), siblings);
|
|
return siblings;
|
|
}
|
|
fn go_down(path: Vec<bool>, node: Node<F, H>, mut siblings: Vec<F>) -> Vec<F> {
|
|
if !node.value.is_none() {
|
|
return siblings;
|
|
}
|
|
if !path[0] {
|
|
siblings.push(node.right.unwrap().hash);
|
|
return Self::go_down(path[1..].to_vec(), *node.left.unwrap(), siblings);
|
|
} else {
|
|
siblings.push(node.left.unwrap().hash);
|
|
return Self::go_down(path[1..].to_vec(), *node.right.unwrap(), siblings);
|
|
}
|
|
}
|
|
pub fn verify(root: F, index: F, value: F, siblings: Vec<F>) -> bool {
|
|
let mut h = H::hash(&[value]);
|
|
let path = Self::get_path(siblings.len() as u32, index);
|
|
for i in 0..siblings.len() {
|
|
if !path[i] {
|
|
h = H::hash(&[h, siblings[siblings.len() - 1 - i]]);
|
|
} else {
|
|
h = H::hash(&[siblings[siblings.len() - 1 - i], h]);
|
|
}
|
|
}
|
|
if h == root {
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use ark_std::UniformRand;
|
|
pub type Fr = ark_bn254::Fr; // scalar field
|
|
|
|
#[test]
|
|
fn test_path() {
|
|
assert_eq!(
|
|
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(0_u32)),
|
|
[false, false, false, false, false, false, false, false]
|
|
);
|
|
assert_eq!(
|
|
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(1_u32)),
|
|
[true, false, false, false, false, false, false, false]
|
|
);
|
|
assert_eq!(
|
|
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(2_u32)),
|
|
[false, true, false, false, false, false, false, false]
|
|
);
|
|
assert_eq!(
|
|
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(3_u32)),
|
|
[true, true, false, false, false, false, false, false]
|
|
);
|
|
assert_eq!(
|
|
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(254_u32)),
|
|
[false, true, true, true, true, true, true, true]
|
|
);
|
|
assert_eq!(
|
|
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(255_u32)),
|
|
[true, true, true, true, true, true, true, true]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_new_empty_tree() {
|
|
let (root, mt) = MerkleTree::<Fr, Keccak256Hash<Fr>>::commit(&[]);
|
|
assert_eq!(mt.root.hash, Fr::from(0_u32));
|
|
assert_eq!(root, Fr::from(0_u32));
|
|
}
|
|
|
|
#[test]
|
|
fn test_proof() {
|
|
type MT = MerkleTree<Fr, Keccak256Hash<Fr>>;
|
|
|
|
let values = [
|
|
Fr::from(0_u32),
|
|
Fr::from(1_u32),
|
|
Fr::from(2_u32),
|
|
Fr::from(3_u32),
|
|
Fr::from(200_u32),
|
|
Fr::from(201_u32),
|
|
Fr::from(202_u32),
|
|
Fr::from(203_u32),
|
|
];
|
|
|
|
let (root, mt) = MT::commit(&values);
|
|
assert_eq!(
|
|
root.to_string(),
|
|
"6195952497672867974990959901930625199810318409246598214215524466855665265259"
|
|
);
|
|
|
|
let index = 3;
|
|
let index_F = Fr::from(index as u32);
|
|
let siblings = mt.open(index_F);
|
|
|
|
assert!(MT::verify(root, index_F, values[index], siblings));
|
|
}
|
|
|
|
#[test]
|
|
fn test_proofs() {
|
|
type MT = MerkleTree<Fr, Keccak256Hash<Fr>>;
|
|
let mut rng = ark_std::test_rng();
|
|
|
|
let n_values = 64;
|
|
let mut values: Vec<Fr> = Vec::new();
|
|
for _i in 0..n_values {
|
|
let v = Fr::rand(&mut rng);
|
|
values.push(v);
|
|
}
|
|
|
|
let (root, mt) = MT::commit(&values);
|
|
assert_eq!(mt.nlevels, 6);
|
|
|
|
for i in 0..n_values {
|
|
let i_Fr = Fr::from(i as u32);
|
|
let siblings = mt.open(i_Fr);
|
|
assert!(MT::verify(root, i_Fr, values[i], siblings));
|
|
}
|
|
}
|
|
}
|