redgold_schema/
observation.rs

1use crate::helpers::with_metadata_hashable::{WithMetadataHashable, WithMetadataHashableFields};
2use crate::structs::{Observation, ObservationMetadata, ObservationProof, Proof};
3use crate::{util, Hash, HashClear, StructMetadata};
4use itertools::Itertools;
5//
6// impl HashClear for Observation {
7//     fn hash_clear(&mut self) {
8//         for x in self.struct_metadata_opt() {
9//             x.hash_clear();
10//         }
11//     }
12// }
13//
14// impl WithMetadataHashableFields for Observation {
15//     fn struct_metadata_opt(&mut self) -> Option<&mut StructMetadata> {
16//         self.struct_metadata.as_mut()
17//     }
18//
19//     fn struct_metadata_opt_ref(&self) -> Option<&StructMetadata> {
20//         self.struct_metadata.as_ref()
21//     }
22// }
23
24impl HashClear for ObservationMetadata {
25    fn hash_clear(&mut self) {
26        if let Some(s) = self.struct_metadata.as_mut() {
27            s.hash_clear();
28        }
29    }
30}
31
32impl WithMetadataHashableFields for ObservationMetadata {
33    fn struct_metadata_opt(&mut self) -> Option<&mut StructMetadata> {
34        self.struct_metadata.as_mut()
35    }
36
37    fn struct_metadata_opt_ref(&self) -> Option<&StructMetadata> {
38        self.struct_metadata.as_ref()
39    }
40}
41
42impl Observation {
43    pub fn leafs(&self) -> Vec<Vec<u8>> {
44        self.observations
45            .iter()
46            .map(| r| r.clone().hash_proto_bytes())
47            /*
48                   old code
49            pub fn metadata_hash(&self) -> [u8; 32] {
50                return crate::util::dhash_vec(&self.proto_serialize());
51            }
52                     */
53            .collect::<Vec<Vec<u8>>>()
54    }
55
56    pub fn leafs_hash(&self) -> Vec<Hash> {
57        self.observations
58            .iter()
59            .map(|r| r.hash_or())
60            .collect_vec()
61    }
62
63    pub fn leafs_vec(&self) -> Vec<Vec<u8>> {
64        self.leafs()
65            .iter()
66            .map(|r| r.to_vec())
67            .collect::<Vec<Vec<u8>>>()
68    }
69
70    pub fn build_observation_proofs(&self, obs_tx_hash: &Hash, proof: &Proof) -> Vec<ObservationProof> {
71        let mut res = vec![];
72        let leafs = self.leafs_hash();
73        let merkle_tree = util::merkle::build_root(leafs.clone()).expect("merkle failure");
74        // info!("Store observation leafs len={:?}", leafs.len());
75        for observation_metadata in &self.observations {
76            let hash = observation_metadata.hash_or();
77            let merkle_proof = merkle_tree.proof(hash.clone());
78            let mut op = ObservationProof::default();
79            op.metadata = Some(observation_metadata.clone());
80            op.merkle_proof = Some(merkle_proof);
81            op.proof = Some(proof.clone());
82            op.observation_hash = Some(obs_tx_hash.clone());
83            res.push(op);
84        };
85        res
86    }
87    //
88    // pub fn signable_hash(&self) -> Hash {
89    //     let mut s = self.clone();
90    //     s.proof = None;
91    //     s.calculate_hash()
92    // }
93
94}