lib

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

codec.rs (8863B)


      1 //! Fixed prefix followed by original exact JSON, without escape inflation.
      2 use super::*;
      3 const PREFIX: usize = 117;
      4 const MAGIC: &[u8; 8] = b"RDSTKS1\0";
      5 pub(super) fn encode(
      6     original: &claim::codec::Retained,
      7     supplied: &StockEvidenceRequest,
      8 ) -> Vec<u8> {
      9     let mut out = Vec::with_capacity(PREFIX + supplied.with_json(str::len));
     10     out.extend_from_slice(MAGIC);
     11     out.extend_from_slice(original.frame.header.operation.as_bytes());
     12     out.extend_from_slice(original.frame.header.transaction.as_bytes());
     13     out.extend_from_slice(original.frame.header.head.as_bytes());
     14     out.push(u8::from(supplied.observed_at_unix_ms().is_some()));
     15     out.extend_from_slice(
     16         &supplied
     17             .observed_at_unix_ms()
     18             .map(NonZeroU64::get)
     19             .unwrap_or(0)
     20             .to_be_bytes(),
     21     );
     22     out.extend_from_slice(&(supplied.with_json(str::len) as u32).to_be_bytes());
     23     supplied.with_json(|raw| out.extend_from_slice(raw.as_bytes()));
     24     out
     25 }
     26 pub(super) fn head(header: &ledger::Header, body: &[u8]) -> radroots_domain::CheckpointDigest {
     27     let mut hash = Sha256::new();
     28     hash.update(b"radroots.seller_stock.signing_evidence_chain.v1\0");
     29     hash.update(header.namespace.workspace_id().as_bytes());
     30     hash.update(header.namespace.authority().executor_id().as_bytes());
     31     hash.update(
     32         header
     33             .namespace
     34             .authority()
     35             .generation()
     36             .get()
     37             .to_be_bytes(),
     38     );
     39     hash.update(header.namespace.route_digest().as_bytes());
     40     hash.update(header.actor.participant().as_bytes());
     41     hash.update(
     42         header
     43             .actor
     44             .grant_id()
     45             .map(|value| *value.as_bytes())
     46             .unwrap_or([0; 32]),
     47     );
     48     hash.update(header.operation.as_bytes());
     49     hash.update(header.digest.as_bytes());
     50     hash.update(header.transaction.as_bytes());
     51     hash.update(header.revision.get().to_be_bytes());
     52     hash.update([u8::from(header.previous.is_some())]);
     53     hash.update(
     54         header
     55             .previous
     56             .map(|value| *value.as_bytes())
     57             .unwrap_or([0; 32]),
     58     );
     59     hash.update(Sha256::digest(body));
     60     radroots_domain::CheckpointDigest::from_bytes(hash.finalize().into())
     61 }
     62 pub(in crate::workspace::stock) struct Retained {
     63     pub frame: ledger::Retained,
     64     pub value: StockCapturedEvidence,
     65     projection: Projection,
     66     local_record: Box<radroots_protocol::commerce::DecodedRecord>,
     67 }
     68 pub(in crate::workspace::stock) async fn read_entry(
     69     connection: &mut SqliteConnection,
     70     input: &AttachmentInput,
     71     crypto: &WorkspaceCrypto,
     72     entry: OperationId,
     73 ) -> Result<Option<Retained>, OperationError> {
     74     let Some(frame) = ledger::read(connection, input, crypto, entry).await? else {
     75         return Ok(None);
     76     };
     77     Ok(Some(
     78         Box::pin(read_frame(connection, input, crypto, frame)).await?,
     79     ))
     80 }
     81 async fn read_frame(
     82     connection: &mut SqliteConnection,
     83     input: &AttachmentInput,
     84     crypto: &WorkspaceCrypto,
     85     frame: ledger::Retained,
     86 ) -> Result<Retained, OperationError> {
     87     let body = frame.body.as_slice();
     88     if frame.header.family != ledger::Family::SigningEvidence
     89         || !(PREFIX..=PREFIX + MAX_RAW).contains(&body.len())
     90         || &body[..8] != MAGIC
     91     {
     92         return Err(OperationError::RecoveryRequired);
     93     }
     94     let array = |start, end| {
     95         body[start..end]
     96             .try_into()
     97             .map_err(|_| OperationError::RecoveryRequired)
     98     };
     99     let claim = OperationId::from_bytes(array(8, 40)?);
    100     let transaction = TransactionId::from_bytes(array(40, 72)?);
    101     let original_head = radroots_domain::CheckpointDigest::from_bytes(array(72, 104)?);
    102     let at = u64::from_be_bytes(
    103         body[105..113]
    104             .try_into()
    105             .map_err(|_| OperationError::RecoveryRequired)?,
    106     );
    107     let observed = match (body[104], at) {
    108         (0, 0) => None,
    109         (1, n) if n > 0 => NonZeroU64::new(n),
    110         _ => return Err(OperationError::RecoveryRequired),
    111     };
    112     let length = u32::from_be_bytes(
    113         body[113..PREFIX]
    114             .try_into()
    115             .map_err(|_| OperationError::RecoveryRequired)?,
    116     ) as usize;
    117     if length != body.len() - PREFIX {
    118         return Err(OperationError::RecoveryRequired);
    119     }
    120     let raw = std::str::from_utf8(&body[PREFIX..]).map_err(|_| OperationError::RecoveryRequired)?;
    121     let original = Box::pin(claim::read_entry(connection, input, crypto, claim))
    122         .await?
    123         .ok_or(OperationError::RecoveryRequired)?;
    124     let header = &frame.header;
    125     if original.frame.header.transaction != transaction
    126         || original.frame.header.head != original_head
    127         || header.actor != original.frame.header.actor
    128         || header.related_operation != original.frame.header.related_operation
    129         || header.order != original.frame.header.order
    130         || header.digest != original.frame.header.digest
    131         || header.revision <= original.frame.header.revision
    132         || head(header, body) != header.head
    133     {
    134         return Err(OperationError::RecoveryRequired);
    135     }
    136     let selected = claim::intent(
    137         original.report.bound_plan(),
    138         original.report.recipient(),
    139         CancellationSignal::new(),
    140     )?;
    141     let (_, kind) = SigningOutcome::capture(&selected, raw.into(), observed).into_parts();
    142     let OutcomeKind::Obtained(signed) = kind else {
    143         return Err(OperationError::RecoveryRequired);
    144     };
    145     if signed.observed_at_unix_ms() != observed {
    146         return Err(OperationError::RecoveryRequired);
    147     }
    148     let digest = Sha256::digest(raw.as_bytes()).into();
    149     let rumor = original.report.bound_plan().preparation().rumor();
    150     let logical =
    151         radroots_protocol::private_rumor::DecodedRumor::decode(rumor.protected_wire().as_bytes())
    152             .map_err(|_| OperationError::RecoveryRequired)?;
    153     let local_record = radroots_protocol::commerce::decode(logical.protected_content().as_bytes())
    154         .map_err(|_| OperationError::RecoveryRequired)?;
    155     if local_record.record_id() != rumor.record_id() || logical.event_id() != rumor.event_id() {
    156         return Err(OperationError::RecoveryRequired);
    157     }
    158     let projection = Projection {
    159         operation: original.report.bound_plan().plan().operation_id(),
    160         recipient: original.report.recipient(),
    161         kind: ProjectionKind::Obtained(digest),
    162     };
    163     let receipt = StockEvidenceReceipt::from_committed_store(
    164         CommitAttempt::new(
    165             input.workspace_id(),
    166             projection.operation,
    167             header.digest,
    168             Some(header.transaction),
    169         ),
    170         original.report.attempt_id(),
    171         projection.recipient,
    172         digest,
    173         observed,
    174     )?;
    175     let value = StockCapturedEvidence {
    176         receipt,
    177         raw: Zeroizing::new(raw.into()),
    178     };
    179     let retained = Retained {
    180         frame,
    181         value,
    182         projection,
    183         local_record: Box::new(local_record),
    184     };
    185     retained.confirm(connection).await?;
    186     Ok(retained)
    187 }
    188 impl Retained {
    189     pub(in crate::workspace::stock) async fn confirm(
    190         &self,
    191         connection: &mut SqliteConnection,
    192     ) -> Result<(), OperationError> {
    193         ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?;
    194         ledger::confirm_parts(
    195             connection,
    196             self.frame.header.actor,
    197             self.frame.header.operation,
    198             self.frame.parts_witness,
    199             self.frame.header.parts,
    200         )
    201         .await?;
    202         self.projection
    203             .confirm(
    204                 connection,
    205                 self.frame.header.actor.participant(),
    206                 self.frame.header.operation,
    207             )
    208             .await?;
    209         let count: i64 = sqlx::query_scalar(
    210             "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?",
    211         )
    212         .bind(self.frame.header.actor.participant().as_bytes().as_slice())
    213         .bind(self.frame.header.operation.as_bytes().as_slice())
    214         .fetch_one(connection)
    215         .await
    216         .map_err(|_| OperationError::RecoveryRequired)?;
    217         if count != 0 {
    218             return Err(OperationError::RecoveryRequired);
    219         }
    220         Ok(())
    221     }
    222     pub(in crate::workspace::stock) fn into_history(self) -> ledger::HistoryEntry {
    223         ledger::HistoryEntry {
    224             deficit: None,
    225             delivery: None,
    226             envelope: None,
    227             aborted: None,
    228             preparation: None,
    229             installation: None,
    230             header: self.frame.header,
    231             protected: self.frame.protected,
    232             parts_witness: self.frame.parts_witness,
    233             pools: vec![],
    234             mapping: None,
    235             movements: vec![],
    236             signing: Some(self.projection),
    237             local_record: Some(self.local_record),
    238         }
    239     }
    240 }