Skip to main content

coven_database/
authorship.rs

1//! Another member's authorship of the creations and cells a snapshot carries
2//! (§9.6, §16.1, D7, D9, D11).
3//!
4//! A snapshot's own signature covers what its author's member wrote. For every
5//! owned row created, or cell set, by another member's write, the snapshot
6//! carries that write's signed header and an opening of the needed leaves in
7//! the snapshot audience's part, so it cannot invent their authorship. A
8//! migration write's changes have no leaves; its authenticated header shows
9//! it is one. Openings need only leaf hashes: a device that received a part
10//! whole keeps them and can open any leaf again without the audience key.
11
12use crate::sqlite::StoreSql;
13use crate::store_call::StoreCall;
14use crate::write_encoding::{decoded, encoded};
15use crate::write_schema::WriteSchema;
16use crate::DbError;
17use coven_crypto::AuthorshipHasher;
18use coven_format::authorship::{CellKind, KeptLeaf, Leaf, Multiproof, WriteEvidence};
19use coven_format::merge_fields;
20use coven_format::write::WriteDisposition;
21use coven_format::write_stream::WriteHeaderFrame;
22use coven_foundation::id_source::{KeyId, MemberId};
23use coven_merge::{Audience, ColumnValue, RowId, WriteId};
24use sqlive::rusqlite::params;
25use std::collections::{BTreeMap, BTreeSet};
26
27/// What a loader needs from sync to authenticate another member's write.
28pub trait Authorship: Send + Sync {
29    /// Open the evidence's sealed header with the store key its prefix names,
30    /// and verify its header signature with the signing key of its device's
31    /// member, current in the header's recorded prefix (D9).
32    fn header(&self, evidence: &WriteEvidence) -> Result<WriteHeaderFrame, DbError>;
33
34    /// The keyed leaf hasher of an audience's part sealed with this key (D11).
35    fn hasher(&self, audience: &Audience, key: KeyId) -> Result<AuthorshipHasher, DbError>;
36}
37
38/// A write's signed header and every part root, retained from receipt or a
39/// loaded snapshot (D9).
40#[derive(Clone, Debug, PartialEq, Eq)]
41pub struct HeaderEvidence {
42    /// The exact cleartext `kind | version | prefix` bytes.
43    pub prefix: Vec<u8>,
44    /// The sealed header chunk exactly as stored, with its length field.
45    pub header: Vec<u8>,
46    /// Every part's root, in header order.
47    pub roots: Vec<[u8; 32]>,
48    /// The header signature.
49    pub signature: [u8; coven_crypto::SIGNATURE_LEN],
50}
51
52/// A list of 32-byte hashes as coven's tables store it: the hashes end to
53/// end.
54fn hash_bytes(hashes: &[[u8; 32]]) -> Vec<u8> {
55    hashes.iter().flatten().copied().collect()
56}
57
58/// The hashes a stored list holds. One whose length isn't whole hashes is
59/// `DamagedDatabase` (§19.3).
60fn hash_list(bytes: &[u8]) -> Result<Vec<[u8; 32]>, DbError> {
61    let (hashes, rest) = bytes.as_chunks::<32>();
62    if !rest.is_empty() {
63        return Err(DbError::DamagedDatabase);
64    }
65    Ok(hashes.to_vec())
66}
67
68pub(crate) fn retain_header(
69    db: &StoreSql,
70    write: WriteId,
71    evidence: &HeaderEvidence,
72) -> Result<(), DbError> {
73    let roots = hash_bytes(&evidence.roots);
74    db.execute(
75        "INSERT INTO _coven_write_evidence(write_id,prefix,header,roots,signature) VALUES(?1,?2,?3,?4,?5) ON CONFLICT(write_id) DO NOTHING",
76        params![
77            encoded(merge_fields::encode_write_id(&write))?,
78            evidence.prefix,
79            evidence.header,
80            roots,
81            evidence.signature.as_slice()
82        ],
83    )?;
84    Ok(())
85}
86
87/// A write's stored header evidence. Roots that aren't whole hashes, or a
88/// signature of the wrong width, are `DamagedDatabase` (§19.3).
89fn header(db: &StoreSql, write: WriteId) -> Result<Option<HeaderEvidence>, DbError> {
90    let damaged = |column| {
91        crate::write_encoding::decode_failure(
92            column,
93            sqlive::rusqlite::types::Type::Blob,
94            DbError::DamagedDatabase,
95        )
96    };
97    Ok(db
98        .query(
99            "SELECT prefix,header,roots,signature FROM _coven_write_evidence WHERE write_id=?1",
100            [encoded(merge_fields::encode_write_id(&write))?],
101            |r| {
102                let roots: Vec<u8> = r.get(2)?;
103                let signature: Vec<u8> = r.get(3)?;
104                Ok(HeaderEvidence {
105                    prefix: r.get(0)?,
106                    header: r.get(1)?,
107                    roots: hash_list(&roots).map_err(|_damaged| damaged(2))?,
108                    signature: signature.try_into().map_err(|_wrong_width| damaged(3))?,
109                })
110            },
111        )?
112        .pop())
113}
114
115/// Keep a received part's leaf hashes, so its leaves can be opened later.
116pub(crate) fn retain_leaves(
117    db: &StoreSql,
118    write: WriteId,
119    audience: &Audience,
120    hashes: &[[u8; 32]],
121) -> Result<(), DbError> {
122    let hashes = hash_bytes(hashes);
123    db.execute(
124        "INSERT INTO _coven_part_leaves(write_id,audience,hashes) VALUES(?1,?2,?3) ON CONFLICT(write_id,audience) DO NOTHING",
125        params![
126            encoded(merge_fields::encode_write_id(&write))?,
127            audience,
128            hashes
129        ],
130    )?;
131    Ok(())
132}
133
134/// Whether this device keeps the leaf hashes of `write`'s part in
135/// `audience`, having received it whole.
136pub(crate) fn holds_leaves(
137    db: &StoreSql,
138    write: WriteId,
139    audience: &Audience,
140) -> Result<bool, DbError> {
141    Ok(db.query_row(
142        "SELECT EXISTS(SELECT 1 FROM _coven_part_leaves WHERE write_id=?1 AND audience=?2)",
143        params![encoded(merge_fields::encode_write_id(&write))?, audience],
144        |r| r.get(0),
145    )?)
146}
147
148/// The kept records of `write`'s part in `audience` are forgotten (§16.7):
149/// its leaf hashes go, and the write's header evidence once no part of it
150/// keeps leaves or an opening.
151pub(crate) fn forget_part(
152    db: &StoreSql,
153    write: WriteId,
154    audience: &Audience,
155) -> Result<(), DbError> {
156    let id = encoded(merge_fields::encode_write_id(&write))?;
157    db.execute(
158        "DELETE FROM _coven_part_leaves WHERE write_id=?1 AND audience=?2",
159        params![id, audience],
160    )?;
161    db.execute(
162        "DELETE FROM _coven_write_evidence WHERE write_id=?1
163         AND NOT EXISTS(SELECT 1 FROM _coven_part_leaves WHERE write_id=?1)
164         AND NOT EXISTS(SELECT 1 FROM _coven_part_proofs WHERE write_id=?1)",
165        [id],
166    )?;
167    Ok(())
168}
169
170/// What the snapshot audience's rows need opened in one write.
171#[derive(Default)]
172struct Needs {
173    creations: BTreeSet<RowId>,
174    /// Row, current column, value and the row's present generation.
175    cells: Vec<(RowId, String, ColumnValue<coven_format::value::Value>, u64)>,
176}
177
178/// Every owned row this device holds came from a whole received part or a
179/// snapshot's opening of it, so its evidence is retained.
180fn missing(write: WriteId) -> DbError {
181    tracing::error!(?write, "another member's write lacks retained authorship evidence");
182    DbError::Invariant { what: "another member's write that set an owned row keeps its evidence" }
183}
184
185/// A retained write's plaintext header.
186fn written(
187    db: &StoreSql,
188    write: WriteId,
189) -> Result<Option<coven_format::write::WriteHeader>, DbError> {
190    if let Some(frame) = crate::write_headers::read(db, write)? {
191        return Ok(Some(frame.header));
192    }
193    let header: Option<Vec<u8>> = db
194        .query(
195            "SELECT header FROM _coven_authored_parts WHERE write_id=?1 LIMIT 1",
196            [encoded(merge_fields::encode_write_id(&write))?],
197            |r| r.get(0),
198        )?
199        .pop();
200    header.map(|bytes| Ok(merge_fields::decode_write_header(&bytes)?)).transpose()
201}
202
203/// Who signed a snapshot: its device, and that device's member when known.
204/// The signature itself vouches for whatever they wrote (§16.2).
205#[derive(Clone, Copy, Debug)]
206pub(crate) struct Author {
207    pub(crate) device: coven_foundation::id_source::DeviceId,
208    pub(crate) member: Option<MemberId>,
209}
210
211/// Whether a member other than the snapshot's author made a change in
212/// `write`: the snapshot needs that write's evidence for it.
213fn by_another_member(db: &StoreSql, author: Author, write: WriteId) -> Result<bool, DbError> {
214    Ok(write.device != author.device
215        && (author.member.is_none()
216            || crate::store_state_tables::device_member(db, write.device)? != author.member))
217}
218
219/// Whether this device keeps `write`'s header evidence, leaf hashes and
220/// openings: a snapshot it writes carries evidence only for another member's
221/// writes (D7.5), and its member never changes, so its own member's writes
222/// never need them here. While this device's member is unknown it keeps
223/// every other device's evidence, as [`by_another_member`] reads `None`.
224pub(crate) fn keeps_evidence(
225    db: &StoreSql,
226    call: &StoreCall<'_>,
227    write: WriteId,
228) -> Result<bool, DbError> {
229    let device = call
230        .local_device()
231        .ok_or(DbError::Invariant { what: "a writer connection observes this device" })?;
232    by_another_member(
233        db,
234        Author { device, member: crate::store_state_tables::device_member(db, device)? },
235        write,
236    )
237}
238
239/// Whether a leaf names this row, read through the write's schema version.
240fn same_row(
241    db: &StoreSql,
242    version: u32,
243    current: u32,
244    leaf: &RowId,
245    row: &RowId,
246) -> Result<bool, DbError> {
247    Ok(leaf.key == row.key
248        && leaf.audience == row.audience
249        && crate::source_names::table(db, version, &leaf.table, current)?.as_deref()
250            == Some(row.table.as_str()))
251}
252
253/// Whether a leaf proves this need. The leaves name rows and columns as the
254/// write did, before any later rename.
255fn proves(
256    db: &StoreSql,
257    version: u32,
258    current: u32,
259    leaf: &Leaf,
260    needs: &Needs,
261    creators: &BTreeMap<RowId, Option<coven_format::write_sources::ChangeId>>,
262) -> Result<bool, DbError> {
263    match leaf {
264        Leaf::Creation { row, generation: 0, creator } => {
265            for needed in &needs.creations {
266                if same_row(db, version, current, row, needed)?
267                    && creators.get(needed) == Some(creator)
268                {
269                    return Ok(true);
270                }
271            }
272            Ok(false)
273        }
274        Leaf::Cell { row, generation, kind, column, value } => {
275            let incarnation = match kind {
276                CellKind::Insert => generation + 1,
277                CellKind::Update => *generation,
278            };
279            for (needed, name, needed_value, present) in &needs.cells {
280                if *present == incarnation
281                    && value == needed_value
282                    && same_row(db, version, current, row, needed)?
283                    && crate::source_names::column(
284                        db,
285                        version,
286                        &row.table,
287                        column,
288                        current,
289                        &needed.table,
290                    )?
291                    .as_deref()
292                        == Some(name.as_str())
293                {
294                    return Ok(true);
295                }
296            }
297            Ok(false)
298        }
299        _ => Ok(false),
300    }
301}
302
303/// The evidence a snapshot of `audience` written by `author` carries: every
304/// other member's write that created an owned row, or set a cell of a present
305/// owned row, with that part's needed leaves opened. The snapshot device's
306/// own writes are its signer's.
307pub(crate) fn evidence(
308    db: &StoreSql,
309    call: &StoreCall<'_>,
310    schema: &WriteSchema,
311    audience: &Audience,
312    author: Author,
313) -> Result<Vec<WriteEvidence>, DbError> {
314    let mut needs = BTreeMap::<WriteId, Needs>::new();
315    let mut creators = BTreeMap::new();
316    let other = |write: WriteId| by_another_member(db, author, write);
317    crate::snapshot_view::creations::<DbError>(db, audience, |creation| {
318        let row = creation.row.clone();
319        if crate::ownership::owner_table(schema, &row.table) && other(creation.write)? {
320            let claim =
321                (creation.creator.write != creation.write).then(|| creation.creator.clone());
322            creators.insert(row.clone(), claim);
323            needs.entry(creation.write).or_default().creations.insert(row);
324        }
325        Ok(())
326    })?;
327    crate::snapshot_view::rows(db, call, schema, audience, |merged| {
328        let state = merged.state;
329        let row = state.row();
330        if crate::ownership::owner_table(schema, &row.table) && state.present() {
331            for (column, cell) in state.cells() {
332                if other(cell.write)? {
333                    needs.entry(cell.write).or_default().cells.push((
334                        row.clone(),
335                        column.clone(),
336                        cell.value.clone(),
337                        state.generation(),
338                    ));
339                }
340            }
341        }
342        Ok::<_, DbError>(())
343    })?;
344    let current = crate::transaction_constants::schema_version(db, call)?;
345    let mut evidence = Vec::new();
346    for (write, needs) in needs {
347        let original = header(db, write)?.ok_or(missing(write))?;
348        let plain = written(db, write)?.ok_or(missing(write))?;
349        let proof = if plain.disposition == WriteDisposition::Migration {
350            Multiproof { leaves: 0, revealed: Vec::new(), hidden: Vec::new() }
351        } else {
352            open(db, write, audience, plain.schema_version, current, &needs, &creators)?
353        };
354        evidence.push(WriteEvidence {
355            write,
356            prefix: original.prefix,
357            header: original.header,
358            roots: original.roots,
359            signature: original.signature,
360            proof,
361        });
362    }
363    Ok(evidence)
364}
365
366/// Open the needed leaves of one part: from its kept records and retained
367/// leaf hashes when held whole, or pruning a loaded snapshot's authenticated
368/// openings. A cell kept as a digest opens as the needed cell whose value it
369/// digests (D7.3).
370fn open(
371    db: &StoreSql,
372    write: WriteId,
373    audience: &Audience,
374    version: u32,
375    current: u32,
376    needs: &Needs,
377    creators: &BTreeMap<RowId, Option<coven_format::write_sources::ChangeId>>,
378) -> Result<Multiproof, DbError> {
379    let id = encoded(merge_fields::encode_write_id(&write))?;
380    let hashes: Option<Vec<u8>> = db.query_row(
381        "SELECT (SELECT hashes FROM _coven_part_leaves WHERE write_id=?1 AND audience=?2)",
382        params![id, audience],
383        |r| r.get(0),
384    )?;
385    if let Some(hashes) = hashes {
386        let hashes = hash_list(&hashes)?;
387        let mut leaves = Vec::new();
388        db.for_each::<_, DbError>(
389            "SELECT record FROM _coven_authored_changes WHERE write_id=?1 AND audience=?2 ORDER BY table_name,key",
390            params![id, audience],
391            |r| {
392                let record = coven_format::snapshot_rows::KeptRecord::decode(
393                    &r.get::<_, Vec<u8>>(0)?,
394                )?;
395                leaves.extend(coven_format::authorship::kept_leaves(&record));
396                Ok(())
397            },
398        )?;
399        if leaves.len() != hashes.len() {
400            return Err(DbError::DamagedDatabase);
401        }
402        let mut opened = Vec::with_capacity(leaves.len());
403        for leaf in &leaves {
404            opened.push(opening(db, version, current, leaf, needs, creators)?);
405        }
406        return Ok(Multiproof::from_hashes(&hashes, opened));
407    }
408    let (proof, hashes) = db
409        .query(
410            "SELECT proof,hashes FROM _coven_part_proofs WHERE write_id=?1 AND audience=?2",
411            params![id, audience],
412            |r| Ok((r.get::<_, Vec<u8>>(0)?, r.get::<_, Vec<u8>>(1)?)),
413        )?
414        .pop()
415        .ok_or_else(|| missing(write))?;
416    let proof = decoded(merge_fields::decode_multiproof(&proof))?;
417    let hashes = hash_list(&hashes)?;
418    let keep = proof
419        .opened()?
420        .iter()
421        .map(|leaf| proves(db, version, current, leaf, needs, creators))
422        .collect::<Result<Vec<_>, _>>()?;
423    Ok(proof.retain_opened(&hashes, &keep))
424}
425
426/// The opening of one kept leaf, if it proves a need: a leaf kept whole as
427/// it is, a cell kept as a digest as each needed cell its value matches.
428fn opening(
429    db: &StoreSql,
430    version: u32,
431    current: u32,
432    leaf: &KeptLeaf,
433    needs: &Needs,
434    creators: &BTreeMap<RowId, Option<coven_format::write_sources::ChangeId>>,
435) -> Result<Option<Vec<u8>>, DbError> {
436    let candidates = match leaf {
437        KeptLeaf::Known(leaf) => vec![leaf.clone()],
438        KeptLeaf::Digest { .. } => {
439            let mut candidates = Vec::new();
440            for (_, _, value, _) in &needs.cells {
441                candidates.extend(leaf.with_value(value)?);
442            }
443            candidates
444        }
445        KeptLeaf::Step => Vec::new(),
446    };
447    for candidate in candidates {
448        if proves(db, version, current, &candidate, needs, creators)? {
449            return Ok(Some(candidate.encode()?));
450        }
451    }
452    Ok(None)
453}
454
455/// Authenticate one write's evidence in a loaded snapshot of `audience`: its
456/// header signature, then its opening against that part's signed root. Keep
457/// both for snapshots this device writes later.
458pub(crate) struct AuthenticatedEvidence {
459    pub(crate) opened: WriteHeaderFrame,
460    pub(crate) leaves: Vec<Leaf>,
461    pub(crate) hashes: Vec<[u8; 32]>,
462    pub(crate) part: bool,
463}
464
465pub(crate) fn authenticate(
466    authorship: &dyn Authorship,
467    audience: &Audience,
468    evidence: &WriteEvidence,
469) -> Result<AuthenticatedEvidence, DbError> {
470    let opened = authorship.header(evidence)?;
471    if opened.header.position != evidence.write {
472        return Err(crate::snapshot_error::invalid("write evidence names another write"));
473    }
474    let prefix = coven_format::sealed_write::WriteObjectPrefix::decode(&evidence.prefix)?;
475    let part = opened.parts.iter().position(|part| part.audience == *audience);
476    let (leaves, hashes) = match part {
477        Some(index) => {
478            let hasher = authorship.hasher(audience, prefix.part_keys[index])?;
479            let (root, hashes) = evidence.proof.root_with_leaf_hashes(&hasher)?;
480            if root != evidence.roots[index] {
481                return Err(crate::snapshot_error::invalid(
482                    "write evidence opening differs from its signed root",
483                ));
484            }
485            (evidence.proof.opened()?, hashes)
486        }
487        None if evidence.proof.leaves == 0 => (Vec::new(), Vec::new()),
488        None => {
489            return Err(crate::snapshot_error::invalid(
490                "write evidence opens a part the write does not have",
491            ))
492        }
493    };
494    Ok(AuthenticatedEvidence { opened, leaves, hashes, part: part.is_some() })
495}
496
497/// Retain already authenticated evidence for snapshots this device writes
498/// later: the plaintext header always, the header evidence and opening only
499/// for another member's write ([`keeps_evidence`]).
500pub(crate) fn load(
501    db: &StoreSql,
502    call: &StoreCall<'_>,
503    audience: &Audience,
504    evidence: &WriteEvidence,
505    verified: &AuthenticatedEvidence,
506) -> Result<(), DbError> {
507    crate::write_headers::retain(db, &verified.opened)?;
508    if !keeps_evidence(db, call, evidence.write)? {
509        return Ok(());
510    }
511    retain_header(
512        db,
513        evidence.write,
514        &HeaderEvidence {
515            prefix: evidence.prefix.clone(),
516            header: evidence.header.clone(),
517            roots: evidence.roots.clone(),
518            signature: evidence.signature,
519        },
520    )?;
521    if verified.part {
522        let hashes = hash_bytes(&verified.hashes);
523        db.execute(
524            "INSERT INTO _coven_part_proofs(write_id,audience,proof,hashes) VALUES(?1,?2,?3,?4) ON CONFLICT(write_id,audience) DO UPDATE SET proof=excluded.proof,hashes=excluded.hashes",
525            params![
526                encoded(merge_fields::encode_write_id(&evidence.write))?,
527                audience,
528                encoded(merge_fields::encode_multiproof(&evidence.proof))?,
529                hashes
530            ],
531        )?;
532    }
533    Ok(())
534}
535
536/// Refuse a loaded snapshot of `audience` by `author` that names another
537/// member as creating an owned row, or setting one of its present cells,
538/// without that write's authenticated opening (§9.6, §16.2).
539pub(crate) fn check(
540    db: &StoreSql,
541    call: &StoreCall<'_>,
542    schema: &WriteSchema,
543    audience: &Audience,
544    author: Author,
545    authenticated: &BTreeMap<WriteId, AuthenticatedEvidence>,
546) -> Result<(), DbError> {
547    let current = crate::transaction_constants::schema_version(db, call)?;
548    let refused = || {
549        crate::snapshot_error::invalid(
550            "snapshot names another member's authorship without its write's evidence",
551        )
552    };
553    let other = |write: WriteId| by_another_member(db, author, write);
554    let mut needs = BTreeMap::<WriteId, Needs>::new();
555    let mut creators = BTreeMap::new();
556    crate::ownership::visit::<DbError>(db, audience, |row, creation| {
557        if crate::ownership::owner_table(schema, &row.table) && other(creation.write)? {
558            let claim =
559                (creation.creator.write != creation.write).then(|| creation.creator.clone());
560            creators.insert(row.clone(), claim);
561            needs.entry(creation.write).or_default().creations.insert(row);
562        }
563        Ok(())
564    })?;
565    // The loaded rows are still the snapshot's staged values.
566    let loaded = BTreeSet::from([audience.clone()]);
567    let store = crate::merge_store::MergeStore::from_snapshot(db, call, &schema.schema, &loaded);
568    for declaration in
569        schema.declarations.iter().filter(|d| d.permission == crate::WritePermission::Owner)
570    {
571        let rows = db.query(
572            "SELECT DISTINCT table_name,key,audience FROM _coven_rows WHERE audience=?1 AND table_name=?2",
573            params![audience, declaration.name],
574            crate::row_queries::read_identity,
575        )?;
576        for row in rows {
577            let state = store.row_without_losses(&row)?.state;
578            if !state.present() {
579                continue;
580            }
581            for (column, cell) in state.cells() {
582                if other(cell.write)? {
583                    needs.entry(cell.write).or_default().cells.push((
584                        row.clone(),
585                        column.clone(),
586                        cell.value.clone(),
587                        state.generation(),
588                    ));
589                }
590            }
591        }
592    }
593    for (write, needs) in needs {
594        let Some(verified) = authenticated.get(&write) else {
595            return Err(refused());
596        };
597        if verified.opened.header.disposition == WriteDisposition::Migration {
598            continue;
599        }
600        let version = verified.opened.header.schema_version;
601        let leaves = &verified.leaves;
602        for row in &needs.creations {
603            let single = Needs { creations: BTreeSet::from([row.clone()]), cells: Vec::new() };
604            let mut found = false;
605            for leaf in leaves {
606                found |= proves(db, version, current, leaf, &single, &creators)?;
607            }
608            if !found {
609                return Err(refused());
610            }
611        }
612        for cell in &needs.cells {
613            let single = Needs { creations: BTreeSet::new(), cells: vec![cell.clone()] };
614            let mut found = false;
615            for leaf in leaves {
616                found |= proves(db, version, current, leaf, &single, &creators)?;
617            }
618            if !found {
619                return Err(refused());
620            }
621        }
622    }
623    Ok(())
624}
625
626/// Hash and check a received part's leaves against its signed root, keeping
627/// the hashes for later openings.
628pub(crate) struct PartRoot {
629    hasher: AuthorshipHasher,
630    root: [u8; 32],
631    hashes: Vec<[u8; 32]>,
632}
633
634impl PartRoot {
635    pub(crate) fn new(hasher: AuthorshipHasher, root: [u8; 32]) -> Self {
636        Self { hasher, root, hashes: Vec::new() }
637    }
638
639    /// Add one record's leaves, in stream order.
640    pub(crate) fn record(
641        &mut self,
642        record: coven_format::write::PartRecord<'_>,
643    ) -> Result<(), DbError> {
644        for leaf in coven_format::authorship::record_leaves(record) {
645            self.hashes.push(self.hasher.leaf(&leaf.encode()?));
646        }
647        Ok(())
648    }
649
650    /// Refuse a part whose leaves do not reproduce its signed root.
651    pub(crate) fn finish(self) -> Result<Vec<[u8; 32]>, DbError> {
652        if coven_format::authorship::root_of_hashes(&self.hashes) != self.root {
653            return Err(crate::snapshot_error::invalid(
654                "write part differs from its signed authorship root",
655            ));
656        }
657        Ok(self.hashes)
658    }
659}
660
661#[cfg(test)]
662#[path = "authorship_tests.rs"]
663pub(crate) mod tests;