lib

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

commerce_delivery.rs (10130B)


      1 //! Ordinary delivery uses the same protected original and fresh stock claims.
      2 use super::*;
      3 use crate::session::stock_evidence::DeliveryContext;
      4 use radroots_storage::{
      5     command::DeliveryIntent,
      6     inventory::{StockDeliveryAttemptOutcome, StockDeliveryRequest},
      7 };
      8 use radroots_transport::TargetSet;
      9 
     10 impl CommandRuntime {
     11     #[allow(clippy::too_many_arguments)]
     12     pub(super) async fn deliver_acceptance(
     13         &self,
     14         store: &Shared<dyn AcceptanceStore>,
     15         inventory: &Shared<dyn InventoryStore>,
     16         selection: &AcceptanceSelection,
     17         proof: &AttachmentProof,
     18         resources: &SigningResources,
     19         recipient: radroots_domain::PublicKey,
     20         mode: &RunMode,
     21     ) -> crate::ExecutionResult<()> {
     22         let fail = |e| {
     23             crate::ExecutionFailure::from(Error::operation(
     24                 e,
     25                 OperationContext::retained(selection.operation),
     26             ))
     27         };
     28         // Shared by every acceptance task, including repeats and explicit resume.
     29         // The store still owns cross-process writer exclusion and final witnesses.
     30         let _creation = resources.stock_captures.delivery_serial.lock().await;
     31         resources.stock_captures.ensure_ready().map_err(fail)?;
     32         let current = store
     33             .snapshot(selection.clone(), proof)
     34             .await
     35             .map_err(fail)?;
     36         observe(selection, current.as_ref()).map_err(fail)?;
     37         if current.aborted() || current.installation().is_none() {
     38             return Ok(());
     39         }
     40         let Some(evidence) = current
     41             .recipients()
     42             .iter()
     43             .find(|v| v.recipient == recipient)
     44             .and_then(|v| v.evidence)
     45         else {
     46             return Ok(());
     47         };
     48         let mut selection = selection.clone();
     49         selection.minimum = current.checkpoint();
     50         let index = current
     51             .recipients()
     52             .iter()
     53             .position(|v| v.recipient == recipient)
     54             .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
     55         // This fresh coherent snapshot already authenticates the delivery
     56         // projection; do not repeat the entire protected-history read.
     57         let state = current
     58             .delivery()
     59             .and_then(|values| values.get(index))
     60             .ok_or_else(|| fail(OperationError::UnsupportedOperation))?;
     61         if state.acceptance_satisfied().map_err(fail)?
     62             || (state.selected_attempt_count() != 0 && matches!(mode, RunMode::Command))
     63         {
     64             return Ok(());
     65         }
     66         let route = current
     67             .plan()
     68             .and_then(|plan| plan.routes().iter().find(|v| v.participant() == recipient))
     69             .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
     70         let Some(plan) = self.stock_delivery_plan(state, route, mode).map_err(fail)? else {
     71             return Ok(());
     72         };
     73         let context = || -> Result<DeliveryContext, OperationError> {
     74             Ok(DeliveryContext {
     75                 selection: selection.clone(),
     76                 recipient,
     77                 rewrap: None,
     78                 store: inventory.clone(),
     79                 proof: copy(proof)?,
     80                 _lease: resources.lease.clone(),
     81             })
     82         };
     83         let outer = match state.source() {
     84             Some(source) => source,
     85             None => {
     86                 let source = store
     87                     .signing_evidence(selection.clone(), evidence, proof)
     88                     .await
     89                     .map_err(fail)?
     90                     .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
     91                 if source.receipt() != evidence {
     92                     return Err(fail(OperationError::RecoveryRequired));
     93                 }
     94                 // Prepare credentials before wrapping, then register the obtained
     95                 // outer before another conversion or persistent write can fail.
     96                 let context = context().map_err(fail)?;
     97                 let candidate = source
     98                     .with_json(|raw| self.io.private_envelope(recipient, raw))
     99                     .map_err(fail)?;
    100                 let observed = self
    101                     .io
    102                     .now()
    103                     .ok()
    104                     .and_then(|v| v.get().checked_mul(1000))
    105                     .and_then(NonZeroU64::new);
    106                 let pending = resources
    107                     .stock_captures
    108                     .retain_envelope(context, candidate, observed);
    109                 resources.stock_captures.capture_envelope(&pending).await?
    110             }
    111         };
    112         self.send_stock_delivery(
    113             &resources.stock_captures,
    114             context().map_err(fail)?,
    115             outer,
    116             state,
    117             plan,
    118             None,
    119         )
    120         .await
    121     }
    122     pub(super) fn stock_publication_policy(
    123         &self,
    124         route: &radroots_protocol::nip59::CapturedDmRoute,
    125         original: Option<&DeliveryIntent>,
    126     ) -> Result<(TargetSet, radroots_transport::policy::SatisfactionPolicy), OperationError> {
    127         let allowed = self.io.targets(route)?;
    128         if let Some(original) = original {
    129             if original.targets().targets().iter().any(|target| {
    130                 !allowed
    131                     .targets()
    132                     .iter()
    133                     .any(|v| v.fingerprint() == target.fingerprint())
    134             }) {
    135                 return Err(OperationError::UnverifiedApproval);
    136             }
    137             Ok((original.targets().clone(), original.policy().clone()))
    138         } else {
    139             Ok((allowed, self.io.publication_policy()))
    140         }
    141     }
    142     pub(super) fn stock_delivery_plan(
    143         &self,
    144         state: &radroots_storage::inventory::StockDeliverySummary,
    145         route: &radroots_protocol::nip59::CapturedDmRoute,
    146         mode: &RunMode,
    147     ) -> Result<Option<StockDeliveryPlan>, OperationError> {
    148         if state.acceptance_satisfied()?
    149             || (state.selected_attempt_count() != 0 && matches!(mode, RunMode::Command))
    150         {
    151             return Ok(None);
    152         }
    153         let (targets, policy) = self.stock_publication_policy(route, state.original_intent())?;
    154         let selected = targets
    155             .targets()
    156             .iter()
    157             .filter(|target| {
    158                 !state.targets().iter().any(|v| {
    159                     v.target() == target.fingerprint()
    160                         && (v.accepted() || v.potential_attempts() >= 12)
    161                 })
    162             })
    163             .cloned()
    164             .collect::<Vec<_>>();
    165         if selected.is_empty() {
    166             return Ok(None);
    167         }
    168         let selected = TargetSet::new(selected).map_err(|_| OperationError::RecoveryRequired)?;
    169         Ok(Some(StockDeliveryPlan {
    170             targets,
    171             selected,
    172             policy,
    173         }))
    174     }
    175     /// One transport path for originals and explicitly selected retained outers.
    176     pub(super) async fn send_stock_delivery(
    177         &self,
    178         owner: &crate::session::stock_evidence::Owner,
    179         c: DeliveryContext,
    180         outer: radroots_storage::inventory::StockEnvelopeReceipt,
    181         state: &radroots_storage::inventory::StockDeliverySummary,
    182         plan: StockDeliveryPlan,
    183         selected_event: Option<radroots_domain::EnvelopeEventId>,
    184     ) -> crate::ExecutionResult<()> {
    185         let fail = |e| {
    186             crate::ExecutionFailure::from(Error::operation(
    187                 e,
    188                 OperationContext::retained(c.selection.operation),
    189             ))
    190         };
    191         let deadline = self
    192             .io
    193             .now()
    194             .map_err(fail)?
    195             .get()
    196             .checked_add(30)
    197             .and_then(|v| v.checked_mul(1000))
    198             .and_then(NonZeroU64::new)
    199             .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    200         let intent = DeliveryIntent::new(
    201             &self.io.delivery_id().map_err(fail)?,
    202             outer.event_id(),
    203             &plan.targets,
    204             &plan.policy,
    205             deadline,
    206         )
    207         .and_then(|v| v.with_selection(&plan.selected))
    208         .map_err(fail)?;
    209         // The original outer's capture checkpoint is historical metadata. Use
    210         // the authenticated current selection, including authorization state.
    211         let request = StockDeliveryRequest::new(
    212             c.selection.binding.clone(),
    213             c.selection.minimum,
    214             c.selection.operation,
    215             c.selection.digest,
    216             c.recipient,
    217             intent.clone(),
    218         )
    219         .and_then(|request| request.with_expected_attempt_count(state.attempt_count()))
    220         .map_err(fail)?;
    221         let request = if let Some(event) = selected_event {
    222             request.with_envelope(event).map_err(fail)?
    223         } else {
    224             request
    225         };
    226         let attempt = match c
    227             .store
    228             .prepare_stock_delivery_attempt(request, copy(&c.proof).map_err(fail)?)
    229             .await
    230             .map_err(fail)?
    231         {
    232             StockDeliveryAttemptOutcome::Claimed(attempt) => attempt,
    233             StockDeliveryAttemptOutcome::Retained(_) => return Ok(()),
    234             StockDeliveryAttemptOutcome::Unknown { .. } => {
    235                 return Err(fail(OperationError::RecoveryRequired));
    236             }
    237         };
    238         if attempt.intent() != &intent || attempt.source().receipt() != outer {
    239             return Err(fail(OperationError::RecoveryRequired));
    240         }
    241         let result = self
    242             .io
    243             .publish(
    244                 attempt.transport_request().map_err(fail)?,
    245                 attempt.intent().selected_target_set().map_err(fail)?,
    246             )
    247             .await;
    248         let observed = self
    249             .io
    250             .now()
    251             .ok()
    252             .and_then(|v| v.get().checked_mul(1000))
    253             .and_then(NonZeroU64::new);
    254         let pending = owner.retain_delivery(c, attempt, result, observed);
    255         owner.capture_delivery(&pending).await?;
    256         Ok(())
    257     }
    258 }
    259 
    260 pub(super) struct StockDeliveryPlan {
    261     targets: TargetSet,
    262     selected: TargetSet,
    263     policy: radroots_transport::policy::SatisfactionPolicy,
    264 }