lib

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

replacement_commitment.rs (5290B)


      1 //! Deterministic replacement intent from captured original-source claims.
      2 use super::{DecodedRecord, EncodedCommerceRumor, RecordWireError};
      3 use crate::{command::CapturedTermsInstallation, terms::EncodedTerms};
      4 use alloc::vec;
      5 use radroots_domain::{
      6     ActorRole, AgreementCommitment, CommerceContent, CommerceHeader, CommercePayload, RecordId,
      7     Sequence, SourceId, UnixSeconds,
      8 };
      9 
     10 /// Builds the exact next seller commitment from complete mutually authorized
     11 /// replacement data. This does not authenticate the original records or prove
     12 /// that the base, residual, author heads, authority or stock are current. The
     13 /// executor must independently admit and freeze those inputs before T1.
     14 pub fn replacement_commitment_rumor(
     15     command: &CapturedTermsInstallation,
     16     base: &DecodedRecord,
     17     proposal: &DecodedRecord,
     18     authorization: &DecodedRecord,
     19     seller_head: (RecordId, Sequence),
     20     created_at: UnixSeconds,
     21 ) -> Result<EncodedCommerceRumor, RecordWireError> {
     22     let invalid = RecordWireError::InvalidInput;
     23     let expected = command.context().expected().ok_or(invalid)?;
     24     let CommercePayload::AgreementCommitted(base_commitment) = base.content().payload() else {
     25         return Err(invalid);
     26     };
     27     let CommercePayload::TermsProposed(proposed) = proposal.content().payload() else {
     28         return Err(invalid);
     29     };
     30     let CommercePayload::TermsAuthorized(authorized) = authorization.content().payload() else {
     31         return Err(invalid);
     32     };
     33     let original = base.content().header();
     34     if command.context().actor().role() != ActorRole::Seller
     35         || command.context().actor().participant() != original.seller()
     36         || original.author() != original.seller()
     37         || original.order_id() != Some(expected.order_id())
     38         || expected.agreement() != Some(base.record_id())
     39         || expected.seller_sequence() != base_commitment.seller_sequence()
     40         || base_commitment.authority() != command.context().authority()
     41         || proposed.base_agreement() != Some(base.record_id())
     42         || proposal.record_id() != command.input().proposal()
     43         || authorization.record_id() != command.input().authorization()
     44         || authorized.proposal() != proposal.record_id()
     45         || authorized.terms_digest() != command.input().terms_digest()
     46         || EncodedTerms::capture(proposed.terms())?.digest() != command.input().terms_digest()
     47         || proposal.content().header().author() == authorization.content().header().author()
     48         || expected.buyer_head().is_none()
     49         || seller_head.1.get() < original.author_sequence().get()
     50         || created_at.get() == 0
     51         || created_at >= command.context().not_after()
     52         || created_at >= proposed.expires_at()
     53         || created_at >= authorized.expires_at()
     54     {
     55         return Err(invalid);
     56     }
     57     for record in [base, proposal, authorization] {
     58         let header = record.content().header();
     59         if header.thread_id() != original.thread_id()
     60             || header.order_id() != original.order_id()
     61             || header.buyer() != original.buyer()
     62             || header.seller() != original.seller()
     63             || header.created_at() > created_at
     64             || (header.author() != original.buyer() && header.author() != original.seller())
     65             || (header.author() == original.seller() && header.author_sequence() > seller_head.1)
     66             || (record.record_id() == seller_head.0
     67                 && (header.author() != original.seller()
     68                     || header.author_sequence() != seller_head.1))
     69             || (expected.buyer_head() == Some(record.record_id())
     70                 && header.author() != original.buyer())
     71         {
     72             return Err(invalid);
     73         }
     74     }
     75     let author_sequence = Sequence::new(
     76         seller_head
     77             .1
     78             .get()
     79             .checked_add(1)
     80             .ok_or(RecordWireError::LimitExceeded)?,
     81     )
     82     .map_err(|_| RecordWireError::LimitExceeded)?;
     83     let seller_sequence = Sequence::new(
     84         base_commitment
     85             .seller_sequence()
     86             .get()
     87             .checked_add(1)
     88             .ok_or(RecordWireError::LimitExceeded)?,
     89     )
     90     .map_err(|_| RecordWireError::LimitExceeded)?;
     91     let mut parents = vec![
     92         base.record_id(),
     93         proposal.record_id(),
     94         authorization.record_id(),
     95         seller_head.0,
     96     ];
     97     parents.extend(expected.buyer_head());
     98     parents.sort();
     99     parents.dedup();
    100     let header = CommerceHeader::new(
    101         original.thread_id(),
    102         original.order_id(),
    103         original.seller(),
    104         original.buyer(),
    105         original.seller(),
    106         created_at,
    107         author_sequence,
    108         Some(seller_head.0),
    109         parents
    110             .into_iter()
    111             .map(|id| SourceId::from_bytes(id.into_bytes()))
    112             .collect(),
    113     )
    114     .map_err(|_| invalid)?;
    115     let commitment = AgreementCommitment::new(
    116         Some(base.record_id()),
    117         authorization.record_id(),
    118         command.input().terms_digest(),
    119         command.context().authority(),
    120         seller_sequence,
    121     )
    122     .map_err(|_| invalid)?;
    123     let content = CommerceContent::new(header, CommercePayload::AgreementCommitted(commitment))
    124         .map_err(|_| invalid)?;
    125     EncodedCommerceRumor::capture(&content)
    126 }