proof 0.0.0

Library for interacting with SSZ merkle tree proofs.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use ethereum_types::U256;
use proof::cache::hash_children;
use proof::field::{Node, Primitive};
use proof::{Error, MerkleTreeOverlay, Path, Proof, SerializedProof};

// A's merkle tree
//
//        a_root(0)
//       /         \
//     i(1)       i(2)
//    /   \       /   \
//  a(3) b(4)  c,d(5) p(6)
//
// n(i) => n = node type, i = general index
// i = intermediate, p = padding
#[derive(Debug, Default)]
struct S {
    a: U256,
    b: U256,
    c: u128,
    d: u128,
}

// Implemented by derive macro
impl MerkleTreeOverlay for S {
    fn height() -> u64 {
        2
    }

    fn min_repr_size() -> u64 {
        32
    }

    fn get_node(path: Vec<Path>) -> Result<Node, Error> {
        let p1 = path.first();

        if p1 == Some(&Path::Ident("a".to_string())) {
            if path.len() == 1 {
                Ok(Node::Primitive(vec![Primitive {
                    ident: "a".to_owned(),
                    index: 3,
                    size: 32,
                    offset: 0,
                }]))
            } else {
                // not sure if this will work
                U256::get_node(path[1..].to_vec())
            }
        } else if p1 == Some(&Path::Ident("b".to_string())) {
            if path.len() == 1 {
                Ok(Node::Primitive(vec![Primitive {
                    ident: "b".to_owned(),
                    index: 4,
                    size: 32,
                    offset: 0,
                }]))
            } else {
                U256::get_node(path[1..].to_vec())
            }
        } else if p1 == Some(&Path::Ident("c".to_string())) {
            if path.len() == 1 {
                Ok(Node::Primitive(vec![
                    Primitive {
                        ident: "c".to_owned(),
                        index: 5,
                        size: 16,
                        offset: 0,
                    },
                    Primitive {
                        ident: "d".to_owned(),
                        index: 5,
                        size: 16,
                        offset: 16,
                    },
                ]))
            } else {
                U256::get_node(path[1..].to_vec())
            }
        } else if p1 == Some(&Path::Ident("d".to_string())) {
            if path.len() == 1 {
                Ok(Node::Primitive(vec![
                    Primitive {
                        ident: "c".to_owned(),
                        index: 5,
                        size: 16,
                        offset: 0,
                    },
                    Primitive {
                        ident: "d".to_owned(),
                        index: 5,
                        size: 16,
                        offset: 16,
                    },
                ]))
            } else {
                U256::get_node(path[1..].to_vec())
            }
        } else if let Some(p) = p1 {
            Err(Error::InvalidPath(p.clone()))
        } else {
            Err(Error::EmptyPath())
        }
    }
}

#[test]
fn roundtrip_partial() {
    let mut arr = [0_u8; 96];

    let three = U256::from(1);
    let four = U256::from(2);
    four.to_little_endian(&mut arr[0..32]);
    three.to_little_endian(&mut arr[32..64]);

    let two: &[u8] = &hash_children(&arr[64..96], &arr[64..96]);
    arr[64..96].copy_from_slice(two);

    let sp = SerializedProof {
        indices: vec![4, 3, 2],
        chunks: arr.to_vec(),
    };

    let mut p = Proof::<S>::new(sp.clone());
    assert_eq!(p.fill(), Ok(()));
    assert_eq!(Ok(sp), p.extract(vec![Path::Ident("a".to_string())]));
}