Skip to main content

coven_database/
sequence.rs

1//! One committed store prefix, including claims whose contents were refused.
2
3use crate::internal_schema::WRITE_DEVICE_SQL;
4use crate::sqlite::StoreSql;
5use crate::{
6    write_encoding::{counter, slot_counter},
7    DbError,
8};
9use coven_crypto::SigningKey;
10use coven_format::{admin::StoreChange, sequence::SlotHeader, snapshot::LastClaim};
11use coven_foundation::id_source::{DeviceId, MemberId};
12use coven_merge::{ClaimOrder, Slot, WriteId};
13use sqlive::rusqlite::params;
14
15pub(crate) fn applied(db: &StoreSql) -> Result<u64, DbError> {
16    Ok(db.query_row("SELECT applied FROM _coven_sequence WHERE singleton=1", [], |r| {
17        counter(r.get(0)?)
18    })?)
19}
20
21pub(crate) fn set_applied(db: &StoreSql, slot: u64) -> Result<(), DbError> {
22    db.execute(
23        "UPDATE _coven_sequence SET applied=?1 WHERE singleton=1",
24        [slot.to_be_bytes().as_slice()],
25    )?;
26    Ok(())
27}
28
29pub(crate) fn claims(db: &StoreSql) -> Result<Vec<LastClaim>, DbError> {
30    Ok(db.query(
31        "SELECT device,number,digest FROM _coven_last_claims ORDER BY device",
32        [],
33        |r| {
34            Ok(LastClaim {
35                device: r.get::<_, DeviceId>(0)?,
36                number: counter(r.get(1)?)?,
37                digest: r.get(2)?,
38            })
39        },
40    )?)
41}
42
43/// Coverage orders observations from different audience snapshots and their suffixes.
44pub(crate) fn note_record(db: &StoreSql, claim: &LastClaim, through: u64) -> Result<(), DbError> {
45    db.execute("INSERT INTO _coven_last_claims(device,number,digest,through) VALUES(?1,?2,?3,?4) ON CONFLICT(device) DO UPDATE SET number=excluded.number,digest=excluded.digest,through=excluded.through WHERE excluded.through>=through AND excluded.number>=number",
46        params![claim.device,claim.number.to_be_bytes(),claim.digest,through.to_be_bytes()])?;
47    Ok(())
48}
49
50/// A device the store's state names starts with no claim: number zero,
51/// through slot zero. A device with a claim keeps it.
52pub(crate) fn note_device(db: &StoreSql, device: DeviceId) -> Result<(), DbError> {
53    db.execute("INSERT INTO _coven_last_claims(device,number,digest,through) VALUES(?1,zeroblob(8),NULL,zeroblob(8)) ON CONFLICT(device) DO NOTHING",[device])?;
54    Ok(())
55}
56
57pub(crate) fn note_claim(
58    db: &StoreSql,
59    header: &SlotHeader,
60    slot: Slot,
61    digest: [u8; 32],
62) -> Result<(), DbError> {
63    note_record(
64        db,
65        &LastClaim { device: header.device, number: header.claim, digest: Some(digest) },
66        slot.get(),
67    )
68}
69
70pub(crate) fn write_slot(db: &StoreSql, write: WriteId) -> Result<Option<Slot>, DbError> {
71    Ok(db.query_row(
72        &format!(
73            "SELECT (SELECT slot FROM _coven_writes WHERE {WRITE_DEVICE_SQL}=?1 AND number=?2)"
74        ),
75        params![write.device, write.number.to_be_bytes().as_slice()],
76        |r| r.get::<_, Option<Vec<u8>>>(0)?.map(slot_counter).transpose(),
77    )?)
78}
79
80/// Local originals have no containing slot until their batch is applied.
81pub(crate) fn write_order(db: &StoreSql, write: WriteId) -> Result<ClaimOrder, DbError> {
82    Ok(match write_slot(db, write)? {
83        Some(slot) => ClaimOrder::Published { slot, number: write.number },
84        None => ClaimOrder::Local { number: write.number },
85    })
86}
87
88/// Record the irrevocable cut-off introduced by an applied admin slot.
89pub(crate) fn cutoff(db: &StoreSql, slot: Slot, change: &StoreChange) -> Result<(), DbError> {
90    let (device, member, signing) = match change {
91        StoreChange::RemoveDevice { device }
92        | StoreChange::AddDevice { replaces: Some(device), .. } => (Some(*device), None, None),
93        StoreChange::RemoveMember { member } => (None, Some(*member), None),
94        StoreChange::ReplaceMemberKeys { member, expected, .. }
95        | StoreChange::RecoverMember { member, expected, .. } => {
96            (None, Some(*member), Some(expected.signing.as_bytes().to_vec()))
97        }
98        _ => return Ok(()),
99    };
100    db.execute(
101        "INSERT INTO _coven_cutoffs(slot,device,member,signing) VALUES(?1,?2,?3,?4)",
102        params![slot.get().to_be_bytes().as_slice(), device, member, signing],
103    )?;
104    Ok(())
105}
106
107/// Replace every recorded cut-off with `cutoffs`, as a reload's state
108/// settles them.
109pub(crate) fn replace_cutoffs(
110    db: &StoreSql,
111    cutoffs: Vec<(Slot, StoreChange)>,
112) -> Result<(), DbError> {
113    db.execute("DELETE FROM _coven_cutoffs", [])?;
114    for (slot, change) in cutoffs {
115        cutoff(db, slot, &change)?;
116    }
117    Ok(())
118}
119
120/// Why a lower slot permanently excludes an original write.
121#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
122pub enum WriteCutoff {
123    /// The device was removed or replaced.
124    DeviceRemoved,
125    /// The member was removed.
126    MemberRemoved,
127    /// The member's signing and sealing keys were replaced.
128    MemberKeysReplaced,
129}
130
131/// The earliest prior removal or replacement that refuses this original.
132pub(crate) fn refusal(
133    db: &StoreSql,
134    slot: Slot,
135    device: DeviceId,
136    member: MemberId,
137    signer: &SigningKey,
138) -> Result<Option<(Slot, WriteCutoff)>, DbError> {
139    Ok(db.query("SELECT slot,device,signing FROM _coven_cutoffs WHERE slot<?1 AND (device=?2 OR (member=?3 AND (signing IS NULL OR signing=?4))) ORDER BY slot LIMIT 1",
140        params![slot.get().to_be_bytes().as_slice(),device,member,signer.as_bytes().as_slice()],
141        |r| {
142            let cause = if r.get::<_,Option<Vec<u8>>>(1)?.is_some() { WriteCutoff::DeviceRemoved }
143                else if r.get::<_,Option<Vec<u8>>>(2)?.is_some() { WriteCutoff::MemberKeysReplaced }
144                else { WriteCutoff::MemberRemoved };
145            Ok((slot_counter(r.get(0)?)?, cause))
146        })?.pop())
147}
148
149pub(crate) fn refused(db: &StoreSql, write: WriteId) -> Result<bool, DbError> {
150    Ok(db.query_row(&format!("SELECT EXISTS(SELECT 1 FROM _coven_writes w JOIN _coven_write_refusals r ON r.slot=w.slot WHERE {WRITE_DEVICE_SQL}=?1 AND w.number=?2)"),
151        params![write.device,write.number.to_be_bytes().as_slice()],|r|r.get(0))?)
152}
153
154#[cfg(test)]
155#[path = "sequence_tests.rs"]
156pub(crate) mod tests;