lib

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

commerce_rewrap.rs (9882B)


      1 //! Explicit wrapping never renews original business signing or dispatch authority.
      2 use super::*;
      3 use crate::session::stock_evidence::DeliveryContext;
      4 use radroots_storage::inventory::{StockEnvelopeRequest, StockRewrapOutcome, StockRewrapRequest};
      5 
      6 fn request(
      7     selection: &AcceptanceSelection,
      8     recipient: PublicKey,
      9 ) -> Result<StockEnvelopeRequest, OperationError> {
     10     StockEnvelopeRequest::new(
     11         selection.binding.clone(),
     12         selection.minimum,
     13         selection.operation,
     14         selection.digest,
     15         recipient,
     16         None,
     17     )
     18 }
     19 /// Separate authenticated observations, never a new wrapping or send permit.
     20 pub(in crate::session) async fn status(
     21     inventory: &Shared<dyn InventoryStore>,
     22     selection: &AcceptanceSelection,
     23     recipient: PublicKey,
     24     id: OperationId,
     25     proof: &AttachmentProof,
     26 ) -> Result<AcceptanceRewrapStatus, OperationError> {
     27     let state = inventory
     28         .stock_rewrap_attempt(
     29             StockRewrapRequest::new(request(selection, recipient)?, id),
     30             copy(proof)?,
     31         )
     32         .await?;
     33     if let Some(state) = &state {
     34         let admission = state.admission();
     35         let original = admission.original();
     36         if admission.rewrap_id() != id
     37             || !same(original.attempt(), selection)
     38             || original.recipient() != recipient
     39             || admission.checkpoint().authority() != selection.minimum.authority()
     40         {
     41             return Err(OperationError::RecoveryRequired);
     42         }
     43     }
     44     let delivery = if let Some(outer) = state.as_ref().and_then(|state| state.envelope()) {
     45         let summary = inventory
     46             .stock_delivery_summary(
     47                 request(selection, recipient)?.with_envelope(outer.event_id()),
     48                 copy(proof)?,
     49             )
     50             .await?;
     51         if summary.source() != Some(outer) {
     52             return Err(OperationError::RecoveryRequired);
     53         }
     54         Some(summary)
     55     } else {
     56         None
     57     };
     58     Ok(AcceptanceRewrapStatus {
     59         id,
     60         recipient,
     61         state,
     62         delivery,
     63     })
     64 }
     65 impl CommandRuntime {
     66     #[allow(clippy::too_many_arguments)]
     67     pub(in crate::session) async fn run_stock_rewrap(
     68         &self,
     69         store: Shared<dyn AcceptanceStore>,
     70         inventory: Shared<dyn InventoryStore>,
     71         selection: AcceptanceSelection,
     72         proof: &AttachmentProof,
     73         resources: SigningResources,
     74         recipient: PublicKey,
     75         id: OperationId,
     76         mode: RunMode,
     77     ) -> crate::ExecutionResult<AcceptanceRewrapStatus> {
     78         let fail = |e| {
     79             crate::ExecutionFailure::from(Error::operation(
     80                 e,
     81                 OperationContext::retained(selection.operation),
     82             ))
     83         };
     84         if !self.io.enabled() {
     85             return Err(fail(OperationError::UnsupportedOperation));
     86         }
     87         let _creation = resources.stock_captures.delivery_serial.lock().await;
     88         resources.stock_captures.ensure_ready().map_err(fail)?;
     89         let snapshot = store
     90             .snapshot(selection.clone(), proof)
     91             .await
     92             .map_err(fail)?;
     93         observe(&selection, snapshot.as_ref()).map_err(fail)?;
     94         let installed = snapshot
     95             .installation()
     96             .ok_or_else(|| fail(OperationError::MissingHistory))?;
     97         if snapshot.aborted() {
     98             return Err(fail(OperationError::InvalidCommand));
     99         }
    100         let evidence = snapshot
    101             .recipients()
    102             .iter()
    103             .find(|entry| entry.recipient == recipient)
    104             .and_then(|entry| entry.evidence)
    105             .ok_or_else(|| fail(OperationError::MissingHistory))?;
    106         let mut current = selection.clone();
    107         current.minimum = snapshot.checkpoint();
    108         let original = inventory
    109             .stock_envelope(
    110                 request(&current, recipient).map_err(fail)?,
    111                 copy(proof).map_err(fail)?,
    112             )
    113             .await
    114             .map_err(fail)?
    115             .ok_or_else(|| fail(OperationError::MissingHistory))?;
    116         let original = original.receipt();
    117         if original.rewrap_admission_transaction_id().is_some()
    118             || original.evidence() != evidence
    119             || original.installation_transaction_id()
    120                 != installed
    121                     .attempt
    122                     .transaction_id()
    123                     .ok_or_else(|| fail(OperationError::RecoveryRequired))?
    124         {
    125             return Err(fail(OperationError::RecoveryRequired));
    126         }
    127         let route = snapshot
    128             .plan()
    129             .and_then(|plan| {
    130                 plan.routes()
    131                     .iter()
    132                     .find(|route| route.participant() == recipient)
    133             })
    134             .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    135         let mut view = status(&inventory, &current, recipient, id, proof)
    136             .await
    137             .map_err(fail)?;
    138         if matches!(mode, RunMode::Command) && view.state.is_none() {
    139             let index = snapshot
    140                 .recipients()
    141                 .iter()
    142                 .position(|entry| entry.recipient == recipient)
    143                 .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    144             let prior = snapshot
    145                 .delivery()
    146                 .and_then(|values| values.get(index))
    147                 .ok_or_else(|| fail(OperationError::UnsupportedOperation))?;
    148             let (targets, _) = self
    149                 .stock_publication_policy(route, prior.original_intent())
    150                 .map_err(fail)?;
    151             if targets.targets().iter().all(|target| {
    152                 prior.targets().iter().any(|entry| {
    153                     entry.target() == target.fingerprint() && entry.potential_attempts() >= 12
    154                 })
    155             }) {
    156                 return Err(fail(OperationError::DeliveryAttemptLimit));
    157             }
    158             let source = store
    159                 .signing_evidence(current.clone(), evidence, proof)
    160                 .await
    161                 .map_err(fail)?
    162                 .ok_or_else(|| fail(OperationError::MissingHistory))?;
    163             if source.receipt() != evidence {
    164                 return Err(fail(OperationError::RecoveryRequired));
    165             }
    166             let context = DeliveryContext {
    167                 selection: current.clone(),
    168                 recipient,
    169                 store: inventory.clone(),
    170                 proof: copy(proof).map_err(fail)?,
    171                 _lease: resources.lease.clone(),
    172                 rewrap: None,
    173             };
    174             let pending = resources
    175                 .stock_captures
    176                 .retain_rewrap_admission(context, original, id);
    177             match resources.stock_captures.prepare_rewrap(&pending).await? {
    178                 StockRewrapOutcome::Claimed(admitted) => {
    179                     // Prepare original credentials before local key generation.
    180                     let context = DeliveryContext {
    181                         selection: current.clone(),
    182                         recipient,
    183                         store: inventory.clone(),
    184                         proof: copy(proof).map_err(fail)?,
    185                         _lease: resources.lease.clone(),
    186                         rewrap: Some(*admitted),
    187                     };
    188                     let now = self.io.now().map_err(fail)?;
    189                     if now < admitted.prepared_at() || now >= admitted.expires_at() {
    190                         return Err(fail(OperationError::DeadlineExceeded));
    191                     }
    192                     let candidate = source
    193                         .with_json(|raw| self.io.private_envelope(recipient, raw))
    194                         .map_err(fail)?;
    195                     let observed = self
    196                         .io
    197                         .now()
    198                         .ok()
    199                         .and_then(|v| v.get().checked_mul(1000))
    200                         .and_then(NonZeroU64::new);
    201                     let pending = resources
    202                         .stock_captures
    203                         .retain_envelope(context, candidate, observed);
    204                     resources.stock_captures.capture_envelope(&pending).await?;
    205                 }
    206                 StockRewrapOutcome::Retained(_) => {}
    207                 StockRewrapOutcome::Unknown(_) => {
    208                     return Err(fail(OperationError::RecoveryRequired));
    209                 }
    210             }
    211             view = status(&inventory, &current, recipient, id, proof)
    212                 .await
    213                 .map_err(fail)?;
    214         }
    215         // Existing/uncaptured admissions remain unknown. Resume never generates
    216         // keys or another inner signature, even after restart or a lost waiter.
    217         if let Some(outer) = view.state.as_ref().and_then(|state| state.envelope()) {
    218             let summary = view
    219                 .delivery
    220                 .as_ref()
    221                 .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    222             if let Some(plan) = self
    223                 .stock_delivery_plan(summary, route, &mode)
    224                 .map_err(fail)?
    225             {
    226                 let context = DeliveryContext {
    227                     selection: current.clone(),
    228                     recipient,
    229                     store: inventory.clone(),
    230                     proof: copy(proof).map_err(fail)?,
    231                     _lease: resources.lease.clone(),
    232                     rewrap: None,
    233                 };
    234                 self.send_stock_delivery(
    235                     &resources.stock_captures,
    236                     context,
    237                     outer,
    238                     summary,
    239                     plan,
    240                     Some(outer.event_id()),
    241                 )
    242                 .await?;
    243                 view = status(&inventory, &current, recipient, id, proof)
    244                     .await
    245                     .map_err(fail)?;
    246             }
    247         }
    248         Ok(view)
    249     }
    250 }