lib

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

codec.rs (5915B)


      1 use super::*;
      2 pub(in crate::workspace::stock) struct Retained {
      3     pub frame: ledger::Retained,
      4     pub report: StockSigningAttempt,
      5     projection: Projection,
      6 }
      7 pub(super) fn head(header: &ledger::Header, body: &[u8]) -> radroots_domain::CheckpointDigest {
      8     let mut hash = Sha256::new();
      9     hash.update(b"radroots.seller_stock.signing_claim_chain.v1\0");
     10     hash.update(header.namespace.workspace_id().as_bytes());
     11     hash.update(header.namespace.authority().executor_id().as_bytes());
     12     hash.update(
     13         header
     14             .namespace
     15             .authority()
     16             .generation()
     17             .get()
     18             .to_be_bytes(),
     19     );
     20     hash.update(header.namespace.route_digest().as_bytes());
     21     hash.update(header.actor.participant().as_bytes());
     22     hash.update(
     23         header
     24             .actor
     25             .grant_id()
     26             .map(|value| *value.as_bytes())
     27             .unwrap_or([0; 32]),
     28     );
     29     hash.update(header.operation.as_bytes());
     30     hash.update(header.digest.as_bytes());
     31     hash.update(header.transaction.as_bytes());
     32     hash.update(header.revision.get().to_be_bytes());
     33     hash.update([u8::from(header.previous.is_some())]);
     34     hash.update(
     35         header
     36             .previous
     37             .map(|value| *value.as_bytes())
     38             .unwrap_or([0; 32]),
     39     );
     40     hash.update(Sha256::digest(body));
     41     radroots_domain::CheckpointDigest::from_bytes(hash.finalize().into())
     42 }
     43 pub(in crate::workspace::stock) async fn read_entry(
     44     connection: &mut SqliteConnection,
     45     input: &AttachmentInput,
     46     crypto: &WorkspaceCrypto,
     47     entry: OperationId,
     48 ) -> Result<Option<Retained>, OperationError> {
     49     let Some(frame) = ledger::read(connection, input, crypto, entry).await? else {
     50         return Ok(None);
     51     };
     52     if frame.header.family != ledger::Family::SigningClaim || frame.body.len() > 16 * 1024 {
     53         return Err(OperationError::RecoveryRequired);
     54     }
     55     let body: Body = super::super::super::closed_record(&frame.body)
     56         .map_err(|_| OperationError::RecoveryRequired)?;
     57     let plan = Box::pin(signing_plan::read_entry(
     58         connection,
     59         input,
     60         crypto,
     61         body.plan_entry,
     62     ))
     63     .await?
     64     .ok_or(OperationError::RecoveryRequired)?;
     65     let selected = intent(&plan.bound, body.recipient, CancellationSignal::new())?;
     66     let header = &frame.header;
     67     if body.version != 1
     68         || header.related_operation != Some(body.operation)
     69         || header.digest != plan.bound.plan().command_digest()
     70         || body.operation != plan.bound.plan().operation_id()
     71         || header.actor != plan.frame.header.actor
     72         || header.order != plan.frame.header.order
     73         || header.revision <= plan.frame.header.revision
     74         || body.plan_transaction != plan.frame.header.transaction
     75         || body.plan_head != plan.frame.header.head
     76         || body.plan_digest != *plan.bound.plan().digest()
     77         || body.intent != *selected.binding().digest()
     78         || body.deadline != plan.bound.preparation().first_issue_deadline()
     79         || body.claimed_at < plan.bound.bound_at()
     80         || body.claimed_at >= body.deadline
     81         || head(header, &frame.body) != header.head
     82     {
     83         return Err(OperationError::RecoveryRequired);
     84     }
     85     let projection = Projection {
     86         operation: body.operation,
     87         recipient: body.recipient,
     88         kind: ProjectionKind::Claim,
     89     };
     90     let report = StockSigningAttempt {
     91         bound: Arc::new(plan.bound),
     92         recipient: body.recipient,
     93         entry: EntryIdentity {
     94             operation: header.operation,
     95             revision: header.revision,
     96             head: header.head,
     97             protected_digest: Sha256::digest(&frame.protected).into(),
     98         },
     99         transaction: header.transaction,
    100         claimed_at: body.claimed_at,
    101         binding: selected.binding(),
    102     };
    103     let retained = Retained {
    104         frame,
    105         report,
    106         projection,
    107     };
    108     retained.confirm(connection).await?;
    109     Ok(Some(retained))
    110 }
    111 impl Retained {
    112     pub(in crate::workspace::stock) fn identity(&self) -> EntryIdentity {
    113         self.report.entry
    114     }
    115     pub(in crate::workspace::stock) async fn confirm(
    116         &self,
    117         connection: &mut SqliteConnection,
    118     ) -> Result<(), OperationError> {
    119         ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?;
    120         ledger::confirm_parts(
    121             connection,
    122             self.frame.header.actor,
    123             self.frame.header.operation,
    124             self.frame.parts_witness,
    125             self.frame.header.parts,
    126         )
    127         .await?;
    128         self.projection
    129             .confirm(
    130                 connection,
    131                 self.frame.header.actor.participant(),
    132                 self.frame.header.operation,
    133             )
    134             .await?;
    135         let count: i64 = sqlx::query_scalar(
    136             "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?",
    137         )
    138         .bind(self.frame.header.actor.participant().as_bytes().as_slice())
    139         .bind(self.frame.header.operation.as_bytes().as_slice())
    140         .fetch_one(connection)
    141         .await
    142         .map_err(|_| OperationError::RecoveryRequired)?;
    143         if count != 0 {
    144             return Err(OperationError::RecoveryRequired);
    145         }
    146         Ok(())
    147     }
    148     pub(in crate::workspace::stock) fn into_history(self) -> ledger::HistoryEntry {
    149         ledger::HistoryEntry {
    150             deficit: None,
    151             delivery: None,
    152             envelope: None,
    153             aborted: None,
    154             preparation: None,
    155             local_record: None,
    156             installation: None,
    157             header: self.frame.header,
    158             protected: self.frame.protected,
    159             parts_witness: self.frame.parts_witness,
    160             pools: vec![],
    161             mapping: None,
    162             movements: vec![],
    163             signing: Some(self.projection),
    164         }
    165     }
    166 }