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 }