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(¤t, 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, ¤t, 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, ¤t, 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, ¤t, recipient, id, proof) 244 .await 245 .map_err(fail)?; 246 } 247 } 248 Ok(view) 249 } 250 }