blockify 0.0.9

A general purpose blockchain library
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use serde::{Deserialize, Serialize};

use super::Hash;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MerkleNode {
    hash: Hash,
    left: Option<Box<MerkleNode>>,
    right: Option<Box<MerkleNode>>,
    center: Option<Box<MerkleNode>>,
}

impl MerkleNode {
    pub fn build(
        hash: Hash,
        left: Option<MerkleNode>,
        center: Option<MerkleNode>,
        right: Option<MerkleNode>,
    ) -> Self {
        Self {
            hash,
            left: left.map(Box::new),
            center: center.map(Box::new),
            right: right.map(Box::new),
        }
    }

    pub fn new() -> Self {
        Self {
            hash: super::random_sha256(),
            left: None,
            center: None,
            right: None,
        }
    }

    pub fn dummy() -> Self {
        Self::new()
    }

    /// Returns the hash of the node.
    pub fn hash(&self) -> &Hash {
        &self.hash
    }

    /// Returns a reference to the left child of the node.
    pub fn left(&self) -> &Option<Box<MerkleNode>> {
        &self.left
    }

    /// Returns a reference to the right child of the node.
    pub fn right(&self) -> &Option<Box<MerkleNode>> {
        &self.right
    }

    pub fn center(&self) -> &Option<Box<MerkleNode>> {
        &self.center
    }
}

/// A Merkle tree.
///
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MerkleTree {
    root: MerkleNode,
    size: usize,
}

impl std::hash::Hash for MerkleTree {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        state.write(self.merkle_root());
    }
}

impl MerkleTree {
    /// Creates a new Merkle tree from the given leaf node hashes.
    pub fn new() -> Self {
        let left = MerkleNode::dummy();
        let center = MerkleNode::dummy();
        let right = MerkleNode::dummy();
        let dummy_root = MerkleNode::build(
            super::random_sha256(),
            Some(left),
            Some(center),
            Some(right),
        );

        Self {
            root: dummy_root,
            size: 0,
        }
    }

    /// Returns the Merkle root of the tree.
    pub fn merkle_root(&self) -> &Hash {
        &self.root.hash
    }

    pub fn push(&mut self, hash: &Hash) {
        self.size += 1;

        let left_hash = self.root.left().as_deref().unwrap().hash();

        if let None = &self.root.center {
            let new_hash = super::sha_from_x([hash, left_hash, self.merkle_root()]);

            let mut new_node = MerkleNode::build(new_hash, None, None, None);

            new_node.left = self.root.left().clone();

            self.root.left = None;
            new_node.center = Some(Box::new(self.root.clone()));

            self.root = new_node;
        } else if let None = self.root.right {
            let center_hash = self.root.center().as_deref().unwrap().hash();
            let new_hash = super::sha_from_x([hash, left_hash, center_hash, self.merkle_root()]);

            let mut new_node = MerkleNode::build(new_hash, None, None, None);

            new_node.left = self.root.left().clone();
            new_node.center = self.root.center().clone();

            self.root.left = None;
            self.root.center = None;
            new_node.center = Some(Box::new(self.root.clone()));

            self.root = new_node;
        } else {
            let center_hash = self.root.center().as_deref().unwrap().hash();
            let right_hash = self.root.right().as_deref().unwrap().hash();
            let new_hash =
                super::sha_from_x([hash, left_hash, center_hash, right_hash, self.merkle_root()]);

            let mut new_node = MerkleNode::build(new_hash, None, None, None);

            new_node.left = Some(Box::new(self.root.clone()));

            self.root = new_node;
        }
    }

    pub fn pop(&self) -> bool {
        todo!()
    }

    pub fn size(&self) -> usize {
        self.size
    }
}