jmt 0.12.0

Jellyfish Merkle Tree
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

#![cfg(feature = "std")]
#![allow(unused)]
use sha2::Sha256;

use crate::{
    proof::{INTERNAL_DOMAIN_SEPARATOR, LEAF_DOMAIN_SEPARATOR},
    KeyHash, SimpleHasher, ValueHash, SPARSE_MERKLE_PLACEHOLDER_HASH,
};

const DESCRIPTION: &'static str =  "Manually computed test vectors for a JMT instantiated with the sha2-256 hash function. Keys and values are hex-encoded byte strings. Neither keys nor values have been pre-hashed.";

use super::vectors::{KeyValuePair, TestVector};

fn internal_hash(left_child_hash: [u8; 32], right_child_hash: [u8; 32]) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(INTERNAL_DOMAIN_SEPARATOR);
    hasher.update(left_child_hash.as_ref());
    hasher.update(right_child_hash.as_ref());
    hasher.finalize()
}

fn leaf_hash(key_hash: KeyHash, value_hash: ValueHash) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(LEAF_DOMAIN_SEPARATOR);
    hasher.update(key_hash.0.as_ref());
    hasher.update(value_hash.0.as_ref());
    hasher.finalize()
}

fn create_vector_for_empty_trie() -> TestVector {
    TestVector {
        expected_root: SPARSE_MERKLE_PLACEHOLDER_HASH,
        data: vec![],
    }
}

fn compute_vector_with_one_leaf() -> TestVector {
    let key = b"hello";
    let key_hash = KeyHash::with::<Sha256>(key);

    let value = b"world";
    let value_hash = ValueHash::with::<Sha256>(value);

    let leaf_hash = leaf_hash(key_hash, value_hash);

    let expected_root = leaf_hash;

    TestVector {
        expected_root: expected_root.into(),
        data: vec![KeyValuePair {
            key: key.to_vec(),
            value: value.to_vec(),
        }],
    }
}

fn compute_vector_with_two_leaves() -> TestVector {
    let left_key = b"hello";
    let left_key_hash = KeyHash::with::<Sha256>(left_key);

    let right_key = b"goodbye";
    let right_key_hash = KeyHash::with::<Sha256>(right_key);

    let value = b"world";
    let value_hash = ValueHash::with::<Sha256>(value);

    let left_leaf_hash = leaf_hash(left_key_hash, value_hash);
    let right_leaf_hash = leaf_hash(right_key_hash, value_hash);

    let expected_root = internal_hash(left_leaf_hash, right_leaf_hash);

    TestVector {
        expected_root: expected_root.into(),
        data: vec![
            KeyValuePair {
                key: left_key.to_vec(),
                value: value.to_vec(),
            },
            KeyValuePair {
                key: right_key.to_vec(),
                value: value.to_vec(),
            },
        ],
    }
}

fn generate_vectors() {
    use super::vectors::TestVectorWrapper;

    let vectors = vec![
        create_vector_for_empty_trie(),
        compute_vector_with_one_leaf(),
        compute_vector_with_two_leaves(),
    ];

    let test_vectors = TestVectorWrapper {
        description: DESCRIPTION.to_string(),
        hash_function: "sha2_256".to_string(),
        vectors,
    };
    let file = std::fs::File::create("sha2_256_vectors.json").unwrap();
    let writer = std::io::BufWriter::new(file);
    serde_json::to_writer_pretty(writer, &test_vectors).unwrap();
}