1use 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
43pub(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
50pub(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
80pub(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
88pub(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
107pub(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#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
122pub enum WriteCutoff {
123 DeviceRemoved,
125 MemberRemoved,
127 MemberKeysReplaced,
129}
130
131pub(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;