issuance.rs (4848B)
1 //! Durable per-recipient claims and original evidence on the stock journal. 2 use super::*; 3 use radroots_domain::{CommandDigest, OperationId, PublicKey, SigningAttemptId, UnixSeconds}; 4 use radroots_storage::{ 5 command::{CommitAttempt, OperationError}, 6 inventory::{ 7 InventoryCheckpointRef, StockEvidenceOutcome, StockEvidenceReceipt, StockEvidenceRequest, 8 }, 9 }; 10 use sha2::{Digest, Sha256}; 11 use sqlx::Row; 12 pub(in crate::workspace) mod claim; 13 pub(in crate::workspace) mod evidence; 14 mod projection; 15 pub(in crate::workspace) mod recovery; 16 pub(in crate::workspace) mod replay_admission; 17 pub(in crate::workspace) mod unissued; 18 pub(super) use claim::read_entry; 19 pub use claim::{ 20 StockClaimOutcome, StockClaimRequest, StockDispatchOutcome, StockDispatchPermit, 21 StockSigningAttempt, StockUnissuedInvocation, 22 }; 23 pub use evidence::{StockCapturedEvidence, StockEvidenceCapture, StockEvidencePage}; 24 pub(super) use projection::{Projection, ProjectionKind, raw_projection}; 25 pub use recovery::StockExactReplayPermit; 26 pub use replay_admission::StockReplayAdmissionReceipt; 27 pub use unissued::{StockUnissuedOutcome, StockUnissuedReceipt}; 28 29 pub(super) async fn check_counts(connection: &mut SqliteConnection) -> Result<(), WorkspaceError> { 30 let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") 31 .fetch_one(&mut *connection) 32 .await 33 .map_err(|_| WorkspaceError::RecoveryRequired)?; 34 if catalog < 11 { 35 return Ok(()); 36 } 37 let (claims, entries): (i64,i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_signing_claims),(SELECT count(*) FROM stock_operations WHERE family=4)").fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 38 let (evidence, captures): (i64,i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_signing_evidence),(SELECT count(*) FROM stock_operations WHERE family=5)").fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 39 if claims != entries || evidence != captures { 40 return Err(WorkspaceError::RecoveryRequired); 41 } 42 if catalog >= 14 { 43 let (facts,entries):(i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM stock_original_unissued),(SELECT count(*) FROM stock_operations WHERE family=8)") 44 .fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 45 if facts != entries { 46 return Err(WorkspaceError::RecoveryRequired); 47 } 48 } 49 if catalog >= 17 { 50 let (attempts, attempt_entries, observations, observation_entries): (i64,i64,i64,i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_delivery_attempts),(SELECT count(*) FROM stock_operations WHERE family=11),(SELECT count(*) FROM stock_delivery_observations),(SELECT count(*) FROM stock_operations WHERE family=12)").fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 51 if attempts != attempt_entries || observations != observation_entries { 52 return Err(WorkspaceError::RecoveryRequired); 53 } 54 } 55 if catalog >= 16 { 56 let (rows, entries): (i64,i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_envelopes),(SELECT count(*) FROM stock_operations WHERE family=10)").fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 57 if rows != entries { 58 return Err(WorkspaceError::RecoveryRequired); 59 } 60 } 61 if catalog >= 15 { 62 let (rows,entries):(i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM stock_replay_admissions),(SELECT count(*) FROM stock_operations WHERE family=9)") 63 .fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 64 if rows != entries { 65 return Err(WorkspaceError::RecoveryRequired); 66 } 67 } 68 if catalog >= 12 { 69 let (agreements, installs, work):(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM stock_agreements),(SELECT count(*) FROM stock_operations WHERE family=6),(SELECT count(*) FROM stock_publication_work)").fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 70 if agreements != installs 71 || work != installs.checked_mul(2).ok_or(WorkspaceError::Capacity)? 72 { 73 return Err(WorkspaceError::RecoveryRequired); 74 } 75 } 76 if catalog >= 13 { 77 let (aborts, entries, states, orders):(i64,i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM stock_aborts),(SELECT count(*) FROM stock_operations WHERE family=7),(SELECT count(*) FROM stock_order_states),(SELECT count(DISTINCT order_id) FROM stock_orders)") 78 .fetch_one(connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 79 if aborts != entries || states != orders { 80 return Err(WorkspaceError::RecoveryRequired); 81 } 82 } 83 Ok(()) 84 }