lib

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

replacement.rs (4341B)


      1 //! Complete current local source admission for the selected replacement.
      2 use super::*;
      3 use radroots_domain::causal::{ReplacementTermsError, ReplacementTermsSelection};
      4 use radroots_protocol::{command::CapturedTermsInstallation, commerce::DecodedRecord};
      5 
      6 fn error(value: ReplacementTermsError) -> OperationError {
      7     match value {
      8         ReplacementTermsError::MissingHistory => OperationError::MissingHistory,
      9         ReplacementTermsError::Uninterpreted => OperationError::UnsupportedOperation,
     10         ReplacementTermsError::Expired => OperationError::DeadlineExceeded,
     11         ReplacementTermsError::ClockAhead => WorkspaceError::Unavailable.into(),
     12         ReplacementTermsError::Conflicted
     13         | ReplacementTermsError::Withdrawn
     14         | ReplacementTermsError::Rejected
     15         | ReplacementTermsError::ConflictingAuthorizations => OperationError::StaleState,
     16         _ => OperationError::InvalidEvidence,
     17     }
     18 }
     19 pub(in crate::workspace::stock) struct Selected<'a> {
     20     pub command: &'a CapturedTermsInstallation,
     21     pub base: &'a DecodedRecord,
     22 }
     23 pub(in crate::workspace::stock) async fn prepare(
     24     connection: &mut SqliteConnection,
     25     input: &AttachmentInput,
     26     crypto: &WorkspaceCrypto,
     27     inventory_read: history::InventoryRead<'_>,
     28     selected: Selected<'_>,
     29     listing_minimum: StockListingCheckpointRef,
     30     observed_at: UnixSeconds,
     31 ) -> Result<Prepared, OperationError> {
     32     let Selected { command, base } = selected;
     33     let expected = command
     34         .context()
     35         .expected()
     36         .ok_or(OperationError::InvalidCommand)?;
     37     let original = base.content().header();
     38     if expected.agreement() != Some(base.record_id())
     39         || original.order_id() != Some(expected.order_id())
     40     {
     41         return Err(OperationError::StaleState);
     42     }
     43     let scope = CausalScope::new(
     44         original.thread_id(),
     45         expected.order_id(),
     46         original.buyer(),
     47         original.seller(),
     48     )
     49     .map_err(|_| OperationError::InvalidEvidence)?;
     50     let authority = inventory_read.authority;
     51     let history = Box::pin(history::prepare(
     52         connection,
     53         input,
     54         crypto,
     55         inventory_read,
     56         scope,
     57         listing_minimum,
     58     ))
     59     .await?;
     60     let nodes: Vec<_> = history
     61         .records
     62         .iter()
     63         .map(|(id, record)| CausalRecord::new(*id, record.content()))
     64         .collect();
     65     let selected = ReplacementTermsSelection::new(
     66         base.record_id(),
     67         command.input().proposal(),
     68         command.input().authorization(),
     69         command.input().terms_digest(),
     70     );
     71     let claim = radroots_domain::causal::prepare_replacement_terms(
     72         scope,
     73         selected,
     74         &nodes,
     75         &history.external,
     76         &history.uninterpreted,
     77         observed_at,
     78     )
     79     .map_err(error)?;
     80     if history
     81         .records
     82         .get(&base.record_id())
     83         .is_none_or(|record| record.content() != base.content())
     84         || claim.base_commitment().seller_sequence() != expected.seller_sequence()
     85         || expected.buyer_head() != history.analysis.buyer_head()
     86         || Some(expected.checkpoint()) != history.checkpoint.as_ref()
     87     {
     88         return Err(OperationError::StaleState);
     89     }
     90     let digest = radroots_protocol::terms::EncodedTerms::capture(claim.terms())
     91         .map_err(|_| OperationError::InvalidEvidence)?
     92         .digest();
     93     if digest != selected.terms_digest() {
     94         return Err(OperationError::InvalidEvidence);
     95     }
     96     let expires = claim.expires_at();
     97     let mut views = BTreeMap::new();
     98     for line in claim.terms().lines() {
     99         if let std::collections::btree_map::Entry::Vacant(entry) =
    100             views.entry(line.source().event_id())
    101         {
    102             let view = super::super::super::public_source::admission::prepare(
    103                 connection,
    104                 input,
    105                 crypto,
    106                 authority,
    107                 line.source(),
    108                 observed_at,
    109             )
    110             .await?;
    111             entry.insert(view);
    112         }
    113         views[&line.source().event_id()].validate(line, true, observed_at)?;
    114     }
    115     Ok(Prepared {
    116         scope,
    117         authorization: selected.authorization(),
    118         digest,
    119         expires,
    120         quote: None,
    121         replacement: Some(selected),
    122         history,
    123         lookup: None,
    124         views,
    125     })
    126 }