lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }