lib

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

checkpoint.rs (6321B)


      1 use super::*;
      2 use sqlx::Row;
      3 pub(in crate::workspace::stock) enum Target {
      4     Minimum(StockSourceCheckpointRef),
      5     Envelope(
      6         EnvelopeEventId,
      7         Option<(Sequence, CheckpointDigest, [u8; 32])>,
      8     ),
      9     Record(RecordId, Option<[u8; 32]>),
     10 }
     11 pub(in crate::workspace::stock) struct Proof {
     12     lower: u64,
     13     upper: u64,
     14     digest: [u8; 32],
     15 }
     16 fn hash() -> Sha256 {
     17     let mut value = Sha256::new();
     18     value.update(b"radroots.seller_stock.source_ancestry_snapshot.v1\0");
     19     value
     20 }
     21 fn hash_row(
     22     hash: &mut Sha256,
     23     revision: u64,
     24     envelope: &[u8],
     25     record: Option<&[u8]>,
     26     transaction: &[u8],
     27     head: &[u8],
     28     protected: &[u8],
     29 ) {
     30     hash.update(revision.to_be_bytes());
     31     hash.update(envelope);
     32     hash.update([u8::from(record.is_some())]);
     33     if let Some(record) = record {
     34         hash.update(record);
     35     }
     36     hash.update(transaction);
     37     hash.update(head);
     38     hash.update((protected.len() as u64).to_be_bytes());
     39     hash.update(protected);
     40 }
     41 impl Proof {
     42     pub async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> {
     43         let mut hash = hash();
     44         for revision in (self.lower..=self.upper).rev() {
     45             let row=sqlx::query("SELECT envelope_id,record_id,transaction_id,chain_head,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_evidence WHERE revision=?").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?;
     46             let envelope: Vec<u8> = row
     47                 .try_get(0)
     48                 .map_err(|_| OperationError::RecoveryRequired)?;
     49             let record: Option<Vec<u8>> = row
     50                 .try_get(1)
     51                 .map_err(|_| OperationError::RecoveryRequired)?;
     52             let tx: Vec<u8> = row
     53                 .try_get(2)
     54                 .map_err(|_| OperationError::RecoveryRequired)?;
     55             let head: Vec<u8> = row
     56                 .try_get(3)
     57                 .map_err(|_| OperationError::RecoveryRequired)?;
     58             let protected: Vec<u8> = row
     59                 .try_get::<Option<Vec<u8>>, _>(4)
     60                 .map_err(|_| OperationError::RecoveryRequired)?
     61                 .ok_or(OperationError::RecoveryRequired)?;
     62             if envelope.len() != 32
     63                 || tx.len() != 32
     64                 || head.len() != 32
     65                 || record.as_ref().is_some_and(|value| value.len() != 32)
     66             {
     67                 return Err(OperationError::RecoveryRequired);
     68             }
     69             hash_row(
     70                 &mut hash,
     71                 revision,
     72                 &envelope,
     73                 record.as_deref(),
     74                 &tx,
     75                 &head,
     76                 &protected,
     77             );
     78         }
     79         let actual: [u8; 32] = hash.finalize().into();
     80         if actual != self.digest {
     81             return Err(OperationError::RecoveryRequired);
     82         }
     83         Ok(())
     84     }
     85 }
     86 pub(in crate::workspace::stock) async fn authenticate(
     87     connection: &mut SqliteConnection,
     88     input: &AttachmentInput,
     89     crypto: &WorkspaceCrypto,
     90     current: SourceCheckpoint,
     91     target: Target,
     92 ) -> Result<Proof, OperationError> {
     93     let upper = current.revision.get();
     94     if let Target::Minimum(minimum) = target
     95         && (minimum.authority() != input.authority() || minimum.revision().get() > upper)
     96     {
     97         return Err(WorkspaceError::StaleCheckpoint.into());
     98     }
     99     let mut expected = current.head;
    100     let mut hash = hash();
    101     for revision in (1..=upper).rev() {
    102         let id:Vec<u8>=sqlx::query_scalar("SELECT envelope_id FROM stock_source_evidence WHERE revision=? AND length(envelope_id)=32").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?;
    103         let envelope = EnvelopeEventId::from_bytes(
    104             id.try_into()
    105                 .map_err(|_| OperationError::RecoveryRequired)?,
    106         );
    107         let retained = record::read(connection, input, crypto, envelope)
    108             .await?
    109             .ok_or(OperationError::RecoveryRequired)?;
    110         let header = &retained.header;
    111         if header.revision.get() != revision || Some(header.head) != expected {
    112             return Err(OperationError::RecoveryRequired);
    113         }
    114         hash_row(
    115             &mut hash,
    116             revision,
    117             envelope.as_bytes(),
    118             header
    119                 .manifest
    120                 .record
    121                 .as_ref()
    122                 .map(|id| id.as_bytes().as_slice()),
    123             header.transaction.as_bytes(),
    124             header.head.as_bytes(),
    125             &retained.protected,
    126         );
    127         let matched = match &target {
    128             Target::Minimum(minimum) if minimum.revision().get() == revision => {
    129                 if minimum.head() != Some(header.head) {
    130                     return Err(WorkspaceError::StaleCheckpoint.into());
    131                 }
    132                 true
    133             }
    134             Target::Envelope(id, observed) if *id == envelope => {
    135                 let digest: [u8; 32] = Sha256::digest(&retained.protected).into();
    136                 if *observed != Some((header.revision, header.head, digest)) {
    137                     return Err(OperationError::RecoveryRequired);
    138                 }
    139                 true
    140             }
    141             Target::Record(id, observed) if header.manifest.record == Some(*id) => {
    142                 if *observed != header.manifest.canonical_digest {
    143                     return Err(OperationError::RecoveryRequired);
    144                 }
    145                 true
    146             }
    147             _ => false,
    148         };
    149         if matched {
    150             return Ok(Proof {
    151                 lower: revision,
    152                 upper,
    153                 digest: hash.finalize().into(),
    154             });
    155         }
    156         expected = header.previous;
    157     }
    158     let absent = match target {
    159         Target::Minimum(value) => value.revision().get() == 0 && value.head().is_none(),
    160         Target::Envelope(_, value) => value.is_none(),
    161         Target::Record(_, value) => value.is_none(),
    162     };
    163     if expected.is_some() || !absent {
    164         return Err(OperationError::RecoveryRequired);
    165     }
    166     Ok(Proof {
    167         lower: 1,
    168         upper,
    169         digest: hash.finalize().into(),
    170     })
    171 }