Skip to main content

qualia_core_db/bundle/stream/publish/
finish.rs

1use super::PlainPublisher;
2use crate::bundle::stream::descriptor::*;
3impl PlainPublisher<'_, '_> {
4    /// Re-encoding is idempotent and emits no sink callbacks. Output remains a disclosure candidate.
5    pub fn finish(
6        &mut self,
7        context_root: &[u8],
8        out: &mut [u8],
9        framing: &mut [u8],
10    ) -> Result<CandidateIdentity, DescriptorError> {
11        self.live()?;
12        if self.context_next != self.page_count() || self.entry_next != self.page_count() {
13            return Err(DescriptorError::Incomplete);
14        }
15        let context = self.context_id.ok_or(DescriptorError::Incomplete)?;
16        if domain_digest(DigestDomain::Context, context_root, framing)? != context {
17            return Err(DescriptorError::Context);
18        }
19        let parsed = decode_context(context_root)?;
20        if parsed.parameters() != self.parameters
21            || parsed.source() != self.source_commit
22            || parsed.entry_count() != self.entry_count()
23        {
24            return Err(DescriptorError::Context);
25        }
26        parsed
27            .page_refs()
28            .matches(&self.context_refs[..self.page_count()])?;
29        let input = BodyInput {
30            context_id: context,
31            context_root,
32            generation: self.parameters.generation,
33            predecessor: self.parameters.predecessor,
34            entries: self.entry_count(),
35            pages: &self.entry_refs[..self.page_count()],
36        };
37        let n = encode_body_into(&input, out)?;
38        let descriptor = domain_digest(DigestDomain::Body, &out[..n], framing)?;
39        let identity = CandidateIdentity {
40            descriptor,
41            context,
42            generation: self.parameters.generation,
43            entries: self.entry_count() as u32,
44        };
45        if let Some(want) = self.completed {
46            if want != identity {
47                return Err(DescriptorError::Commitment);
48            }
49        } else {
50            self.used = self.charge(n)?;
51            self.completed = Some(identity);
52        }
53        Ok(identity)
54    }
55    /// Canonical body length without a second encoding; useful after a successful finish.
56    pub fn body_encoded_length(&self, context_root: &[u8]) -> Result<usize, DescriptorError> {
57        self.live()?;
58        let context = self.context_id.ok_or(DescriptorError::Incomplete)?;
59        let input = BodyInput {
60            context_id: context,
61            context_root,
62            generation: self.parameters.generation,
63            predecessor: self.parameters.predecessor,
64            entries: self.entry_count(),
65            pages: &self.entry_refs[..self.page_count()],
66        };
67        body_encoded_len(&input)
68    }
69}