prolly-map 0.3.0

Content-addressed versioned map storage primitives.
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

use super::invalid;
use crate::prolly::cid::Cid;
use crate::prolly::content_graph::{
    walk_content_graph, ContentGraphLimits, ContentObjectKind, TypedContentObject, TypedContentRoot,
};
use crate::prolly::error::Error;
use crate::prolly::proximity::{ProximityMap, ProximityVerification};
use crate::prolly::store::{MemStore, Store};
use std::collections::HashSet;
use std::sync::Arc;

/// Complete typed PRXI closure sufficient for store-independent verification.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProximityStructuralProof {
    pub descriptor: Cid,
    pub objects: Vec<TypedContentObject>,
}

/// Authenticated structural summary recomputed from proof objects.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProximityStructuralVerification {
    pub descriptor: Cid,
    pub object_count: usize,
    pub summary: ProximityVerification,
}

impl ProximityStructuralProof {
    /// Verify against a descriptor CID already trusted by the caller.
    pub fn verify_for(
        &self,
        expected_descriptor: &Cid,
        limits: &ContentGraphLimits,
    ) -> Result<ProximityStructuralVerification, Error> {
        if &self.descriptor != expected_descriptor {
            return Err(invalid("structural proof targets an unexpected descriptor"));
        }
        self.verify(limits)
    }

    /// Rebuild an isolated content store, check exact closure, then run every
    /// proximity routing, radius, summary, vector, and directory invariant.
    pub fn verify(
        &self,
        limits: &ContentGraphLimits,
    ) -> Result<ProximityStructuralVerification, Error> {
        let (map, object_count) = self.verified_map(limits)?;
        let summary = map.verify()?;
        Ok(ProximityStructuralVerification {
            descriptor: self.descriptor.clone(),
            object_count,
            summary,
        })
    }

    pub(super) fn verified_map(
        &self,
        limits: &ContentGraphLimits,
    ) -> Result<(ProximityMap<Arc<MemStore>>, usize), Error> {
        let store = Arc::new(MemStore::new());
        let mut supplied_cids = HashSet::new();
        let mut supplied_shape = HashSet::new();
        for object in &self.objects {
            if Cid::from_bytes(&object.bytes) != object.root.cid
                || !supplied_cids.insert(object.root.cid.clone())
                || !supplied_shape.insert((object.root.clone(), object.depth))
            {
                return Err(invalid("duplicate or CID-invalid structural proof object"));
            }
            Store::put(&store, object.root.cid.as_bytes(), &object.bytes)
                .map_err(|error| Error::Store(Box::new(error)))?;
        }
        let root = TypedContentRoot::proximity_descriptor(self.descriptor.clone());
        let walked = walk_content_graph(&store, &[root], limits)?;
        let reached: HashSet<_> = walked
            .objects
            .iter()
            .map(|object| (object.root.clone(), object.depth))
            .collect();
        if supplied_shape != reached
            || walked.objects.last().map(|object| object.root.kind)
                != Some(ContentObjectKind::ProximityDescriptor)
        {
            return Err(invalid(
                "structural proof is not the exact descriptor closure",
            ));
        }
        let map = ProximityMap::load(store, self.descriptor.clone())?;
        Ok((map, walked.objects.len()))
    }
}

impl<S> ProximityMap<S>
where
    S: Store + Clone + Send + Sync,
    S::Error: Send + Sync,
{
    /// Capture the authenticated typed closure of this immutable snapshot.
    pub fn prove_structure(
        &self,
        limits: &ContentGraphLimits,
    ) -> Result<ProximityStructuralProof, Error> {
        let root = TypedContentRoot::proximity_descriptor(self.tree().descriptor.clone());
        let walk = walk_content_graph(&self.store_clone(), &[root], limits)?;
        Ok(ProximityStructuralProof {
            descriptor: self.tree().descriptor.clone(),
            objects: walk.objects,
        })
    }
}