commerce_run.rs (24020B)
1 //! One shared T1/S/T2/D algorithm; target hosts implement transactions only. 2 use super::*; 3 use crate::{ 4 Error, OperationContext, 5 session::{ 6 Shared, SignerSession, 7 command::{CommandRuntime, RunMode, SigningResources}, 8 }, 9 }; 10 use alloc::vec::Vec; 11 use core::num::NonZeroU64; 12 use radroots_domain::UnixSeconds; 13 use radroots_protocol::{ 14 commerce::{CommerceSeal, EncodedCommerceRumor}, 15 intent::SigningReplay, 16 }; 17 use radroots_signing::{ 18 issuance::{ExactRecoveryCapability, ExactRecoveryKind, SignedArtifact, SigningIntent}, 19 provider::PrivateText, 20 recovery::ReplayCapability, 21 }; 22 use radroots_storage::inventory::{InventoryStore, StockEvidenceOutcome}; 23 #[path = "commerce_delivery.rs"] 24 mod delivery; 25 #[path = "commerce_rewrap.rs"] 26 mod rewrap; 27 pub(in crate::session) use rewrap::status as rewrap_status; 28 29 fn same(attempt: CommitAttempt, selection: &AcceptanceSelection) -> bool { 30 attempt.workspace_id() == selection.binding.input().workspace_id() 31 && attempt.operation_id() == selection.operation 32 && attempt.command_digest() == selection.digest 33 } 34 pub(crate) fn observe( 35 selection: &AcceptanceSelection, 36 snapshot: &dyn AcceptanceSnapshot, 37 ) -> Result<AcceptanceStatus, OperationError> { 38 let original = snapshot.preparation(); 39 let recipients = snapshot.recipients(); 40 if !same(original.attempt(), selection) 41 || original.attempt().transaction_id().is_none() 42 || recipients 43 .iter() 44 .map(|v| v.recipient) 45 .ne(original.rumor().recipients().iter().copied()) 46 { 47 return Err(OperationError::RecoveryRequired); 48 } 49 if let Some(plan) = snapshot.plan() { 50 CommerceSigningPlan::parse( 51 selection.operation, 52 selection.digest, 53 original.rumor(), 54 plan.protected_wire(), 55 ) 56 .map_err(|_| OperationError::RecoveryRequired)?; 57 } else if recipients 58 .iter() 59 .any(|v| v.claim.is_some() || v.evidence.is_some() || v.original_unissued.is_some()) 60 { 61 return Err(OperationError::RecoveryRequired); 62 } 63 for recipient in &recipients { 64 if let Some(claim) = recipient.claim { 65 let plan = snapshot.plan().ok_or(OperationError::RecoveryRequired)?; 66 let seal = plan 67 .seals() 68 .iter() 69 .find(|v| v.recipient() == recipient.recipient) 70 .ok_or(OperationError::RecoveryRequired)?; 71 if claim.binding 72 != SigningIntent::from_commerce_seal(seal, call(original)?) 73 .map_err(|_| OperationError::RecoveryRequired)? 74 .binding() 75 { 76 return Err(OperationError::RecoveryRequired); 77 } 78 } 79 if let Some(evidence) = recipient.evidence 80 && (!same(evidence.attempt(), selection) 81 || evidence.attempt().transaction_id().is_none() 82 || evidence.recipient() != recipient.recipient 83 || recipient 84 .claim 85 .is_none_or(|v| v.id != evidence.signing_attempt_id())) 86 { 87 return Err(OperationError::RecoveryRequired); 88 } 89 } 90 for recipient in &recipients { 91 if let Some(value) = recipient.original_unissued 92 && (!same(value.attempt, selection) 93 || value.attempt.transaction_id().is_none() 94 || value.recipient != recipient.recipient 95 || recipient.claim.is_none_or(|v| v.id != value.claim) 96 || value.checkpoint.authority() != selection.minimum.authority()) 97 { 98 return Err(OperationError::RecoveryRequired); 99 } 100 } 101 let installation = snapshot.installation(); 102 if snapshot.aborted() 103 && recipients 104 .iter() 105 .any(|v| v.evidence.is_some() || (v.claim.is_some() && v.original_unissued.is_none())) 106 { 107 return Err(OperationError::RecoveryRequired); 108 } 109 if let Some(installed) = installation { 110 let peer = recipients 111 .iter() 112 .find(|v| v.recipient != original.rumor().author()) 113 .ok_or(OperationError::RecoveryRequired)?; 114 if !same(installed.attempt, selection) 115 || installed.attempt.transaction_id().is_none() 116 || installed.order != original.order_id() 117 || installed.record != original.rumor().record_id() 118 || peer.evidence.is_none() 119 || snapshot.aborted() 120 { 121 return Err(OperationError::RecoveryRequired); 122 } 123 } 124 Ok(AcceptanceStatus { 125 delivery: match snapshot.delivery() { 126 Some(values) => { 127 for (value, recipient) in values.iter().zip(&recipients) { 128 if value.checkpoint() != snapshot.checkpoint() 129 || value.source().is_some_and(|source| { 130 !same(source.attempt(), selection) 131 || source.recipient() != recipient.recipient 132 || recipient.evidence != Some(source.evidence()) 133 || installation.is_none_or(|installed| { 134 Some(source.installation_transaction_id()) 135 != installed.attempt.transaction_id() 136 }) 137 }) 138 { 139 return Err(OperationError::RecoveryRequired); 140 } 141 } 142 Some(alloc::boxed::Box::new(values.clone())) 143 } 144 None => None, 145 }, 146 attempt: original.attempt(), 147 record: original.rumor().record_id(), 148 checkpoint: snapshot.checkpoint(), 149 recipients, 150 plan_bound: snapshot.plan().is_some(), 151 installation, 152 aborted: snapshot.aborted(), 153 }) 154 } 155 fn call(original: &StockAcceptanceReceipt) -> Result<ProviderCall, OperationError> { 156 let deadline = original 157 .first_issue_deadline() 158 .get() 159 .checked_mul(1000) 160 .and_then(NonZeroU64::new) 161 .ok_or(OperationError::RecoveryRequired)?; 162 Ok(ProviderCall::new( 163 original.rumor().author(), 164 deadline, 165 CancellationSignal::new(), 166 )) 167 } 168 fn copy(proof: &AttachmentProof) -> Result<AttachmentProof, OperationError> { 169 proof 170 .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) 171 .map_err(Into::into) 172 } 173 impl CommandRuntime { 174 pub(in crate::session) async fn run_acceptance( 175 &self, 176 store: Shared<dyn AcceptanceStore>, 177 inventory: Shared<dyn InventoryStore>, 178 mut selection: AcceptanceSelection, 179 proof: &AttachmentProof, 180 resources: SigningResources, 181 mode: RunMode, 182 ) -> crate::ExecutionResult<AcceptanceStatus> { 183 let retained = OperationContext::retained(selection.operation); 184 let fail = |e| crate::ExecutionFailure::from(Error::operation(e, retained)); 185 let mut snapshot = store 186 .snapshot(selection.clone(), proof) 187 .await 188 .map_err(fail)?; 189 let mut status = observe(&selection, snapshot.as_ref()).map_err(fail)?; 190 if !snapshot.aborted() 191 && snapshot.installation().is_none() 192 && snapshot.recipients().iter().any(|v| { 193 v.recipient != snapshot.preparation().rumor().author() && v.evidence.is_some() 194 }) 195 { 196 selection.minimum = snapshot.checkpoint(); 197 match store 198 .install(selection.clone(), proof) 199 .await 200 .map_err(fail)? 201 { 202 AcceptanceInstallationOutcome::Installed(value) 203 if same(value.attempt, &selection) 204 && value.attempt.transaction_id().is_some() => {} 205 _ => return Err(fail(OperationError::RecoveryRequired)), 206 } 207 snapshot = store 208 .snapshot(selection.clone(), proof) 209 .await 210 .map_err(fail)?; 211 status = observe(&selection, snapshot.as_ref()).map_err(fail)?; 212 } 213 if snapshot.aborted() || !self.io.enabled() { 214 return Ok(status); 215 } 216 self.drain().await?; 217 resources.stock_captures.ensure_ready().map_err(fail)?; 218 if snapshot.plan().is_none() { 219 let Some(signer) = resources.signer.as_ref() else { 220 return Ok(status); 221 }; 222 let plan = self 223 .acceptance_plan(snapshot.preparation(), signer) 224 .await 225 .map_err(fail)?; 226 selection.minimum = snapshot.checkpoint(); 227 match store 228 .bind(selection.clone(), plan, proof) 229 .await 230 .map_err(fail)? 231 { 232 AcceptancePlanOutcome::Bound(anchor) 233 if same(anchor, &selection) && anchor.transaction_id().is_some() => {} 234 _ => return Err(fail(OperationError::RecoveryRequired)), 235 } 236 } 237 let author = snapshot.preparation().rumor().author(); 238 let peer = *snapshot 239 .preparation() 240 .rumor() 241 .recipients() 242 .iter() 243 .find(|v| **v != author) 244 .ok_or_else(|| fail(OperationError::RecoveryRequired))?; 245 drop(snapshot); 246 // A peer commitment is installed before self-history work can fail. 247 for recipient in [peer, author] { 248 let current = store 249 .snapshot(selection.clone(), proof) 250 .await 251 .map_err(fail)?; 252 observe(&selection, current.as_ref()).map_err(fail)?; 253 if current.aborted() { 254 return observe(&selection, current.as_ref()).map_err(fail); 255 } 256 selection.minimum = current.checkpoint(); 257 let facts = current 258 .recipients() 259 .into_iter() 260 .find(|v| v.recipient == recipient) 261 .ok_or_else(|| fail(OperationError::RecoveryRequired))?; 262 if facts.evidence.is_none() { 263 let Some(signer) = resources.signer.as_ref() else { 264 continue; 265 }; 266 resources.stock_captures.ensure_ready().map_err(fail)?; 267 let plan = current 268 .plan() 269 .ok_or_else(|| fail(OperationError::RecoveryRequired))?; 270 if facts.claim.is_some() 271 && (!matches!(&mode, RunMode::Resume) 272 || plan.replay() != SigningReplay::LocalReplaySafe) 273 { 274 continue; 275 } 276 if facts.claim.is_none() 277 && self.io.now().map_err(fail)? >= current.preparation().first_issue_deadline() 278 { 279 continue; 280 } 281 // Recheck every originally selected target and the actual scoped 282 // provider before acquiring any fresh first-dispatch claim. 283 for route in plan.routes() { 284 self.io.targets(route).map_err(fail)?; 285 } 286 let original = current.preparation(); 287 let plan_copy = CommerceSigningPlan::parse( 288 selection.operation, 289 selection.digest, 290 original.rumor(), 291 plan.protected_wire(), 292 ) 293 .map_err(|_| fail(OperationError::RecoveryRequired))?; 294 signer 295 .verify_commerce_plan( 296 call(original).map_err(fail)?, 297 original.rumor(), 298 plan_copy, 299 ) 300 .await 301 .map_err(|_| fail(OperationError::Unauthorized))?; 302 let capture_proof = copy(proof).map_err(fail)?; 303 let capture_selection = selection.clone(); 304 let obtained: Option<(SignedArtifact, AcceptanceClaim)> = if let Some(claim) = 305 facts.claim 306 { 307 if !matches!(&mode, RunMode::Resume) 308 || plan.replay() != SigningReplay::LocalReplaySafe 309 { 310 None 311 } else { 312 let (request, report) = store 313 .exact_replay( 314 selection.clone(), 315 recipient, 316 call(original).map_err(fail)?, 317 proof, 318 ) 319 .await 320 .map_err(fail)?; 321 if report != claim || request.original().binding() != claim.binding { 322 return Err(fail(OperationError::RecoveryRequired)); 323 } 324 self.ensure_ready()?; 325 match signer.recover_exact(request).await.into_parts().1 { 326 ExactRecoveryKind::Obtained(artifact) => Some((artifact, report)), 327 ExactRecoveryKind::Rejected(rejected) => { 328 return Err(crate::ExecutionFailure::rejected( 329 selection.operation, 330 rejected, 331 )); 332 } 333 _ => None, 334 } 335 } 336 } else { 337 if self.io.now().map_err(fail)? >= original.first_issue_deadline() { 338 continue; 339 } 340 match store 341 .claim(selection.clone(), recipient, proof) 342 .await 343 .map_err(fail)? 344 { 345 AcceptanceClaimOutcome::Fresh(permit) => { 346 let report = permit.claim(); 347 let seal = plan 348 .seals() 349 .iter() 350 .find(|v| v.recipient() == recipient) 351 .ok_or_else(|| fail(OperationError::RecoveryRequired))?; 352 let expected = SigningIntent::from_commerce_seal( 353 seal, 354 call(original).map_err(fail)?, 355 ) 356 .map_err(|_| fail(OperationError::RecoveryRequired))? 357 .binding(); 358 if report.binding != expected { 359 return Err(fail(OperationError::RecoveryRequired)); 360 } 361 self.ensure_ready()?; 362 resources.stock_captures.ensure_ready().map_err(fail)?; 363 match permit 364 .dispatch(signer, CancellationSignal::new()) 365 .await 366 .map_err(fail)? 367 { 368 AcceptanceDispatchOutcome::Obtained(actual, artifact) => { 369 if actual != report { 370 resources.stock_captures.retain_obtained( 371 crate::session::stock_evidence::ObtainedContext { 372 selection: capture_selection, 373 claim: report, 374 recipient, 375 store: inventory.clone(), 376 proof: capture_proof, 377 lease: resources.lease.clone(), 378 }, 379 artifact, 380 ); 381 return Err(fail(OperationError::RecoveryRequired)); 382 } 383 Some((artifact, report)) 384 } 385 AcceptanceDispatchOutcome::Unissued(observation) => { 386 let pending = resources.stock_captures.retain_unissued( 387 capture_selection.clone(), 388 report, 389 recipient, 390 observation, 391 resources.lease.clone(), 392 ); 393 if !matches!( 394 resources.stock_captures.capture_unissued(&pending).await?, 395 AcceptanceUnissuedOutcome::Committed(_) 396 ) { 397 return Err(fail(OperationError::RecoveryRequired)); 398 } 399 None 400 } 401 AcceptanceDispatchOutcome::Rejected(actual, rejected) 402 if actual == report => 403 { 404 return Err(crate::ExecutionFailure::rejected( 405 selection.operation, 406 rejected, 407 )); 408 } 409 AcceptanceDispatchOutcome::Unknown(actual, _) 410 if actual == report => 411 { 412 None 413 } 414 _ => return Err(fail(OperationError::RecoveryRequired)), 415 } 416 } 417 AcceptanceClaimOutcome::Existing(_) => None, 418 AcceptanceClaimOutcome::Unknown(_) => { 419 return Err(fail(OperationError::RecoveryRequired)); 420 } 421 } 422 }; 423 if let Some((artifact, claim)) = obtained { 424 let pending = resources.stock_captures.retain_obtained( 425 crate::session::stock_evidence::ObtainedContext { 426 selection: capture_selection, 427 claim, 428 recipient, 429 store: inventory.clone(), 430 proof: capture_proof, 431 lease: resources.lease.clone(), 432 }, 433 artifact, 434 ); 435 if !matches!( 436 resources 437 .stock_captures 438 .capture_obtained(&pending) 439 .await 440 .map_err(|e| e.with_context(retained))?, 441 StockEvidenceOutcome::Committed(_) 442 ) { 443 return Err(fail(OperationError::RecoveryRequired)); 444 } 445 } 446 } 447 if recipient == peer { 448 let captured = store 449 .snapshot(selection.clone(), proof) 450 .await 451 .map_err(fail)?; 452 observe(&selection, captured.as_ref()).map_err(fail)?; 453 let peer_ready = captured 454 .recipients() 455 .iter() 456 .any(|v| v.recipient == peer && v.evidence.is_some()); 457 if peer_ready && captured.installation().is_none() { 458 selection.minimum = captured.checkpoint(); 459 match store 460 .install(selection.clone(), proof) 461 .await 462 .map_err(fail)? 463 { 464 AcceptanceInstallationOutcome::Installed(value) 465 if same(value.attempt, &selection) 466 && value.attempt.transaction_id().is_some() => {} 467 _ => return Err(fail(OperationError::RecoveryRequired)), 468 } 469 } 470 } 471 self.deliver_acceptance( 472 &store, &inventory, &selection, proof, &resources, recipient, &mode, 473 ) 474 .await?; 475 } 476 let final_view = store 477 .snapshot(selection.clone(), proof) 478 .await 479 .map_err(fail)?; 480 observe(&selection, final_view.as_ref()).map_err(fail) 481 } 482 async fn acceptance_plan( 483 &self, 484 original: &StockAcceptanceReceipt, 485 signer: &SignerSession, 486 ) -> Result<VerifiedCommerceSigningPlan, OperationError> { 487 let rumor: &EncodedCommerceRumor = original.rumor(); 488 let now: UnixSeconds = self.io.now()?; 489 if now < original.prepared_at() || now >= original.first_issue_deadline() { 490 return Err(OperationError::DeadlineExceeded); 491 } 492 let state = signer 493 .observe() 494 .await 495 .map_err(|_| OperationError::Unauthorized)?; 496 if state.identity() != rumor.author() { 497 return Err(OperationError::Unauthorized); 498 } 499 let replay = match state.exact_issuance() { 500 Some(_) if state.exact_recovery() == ExactRecoveryCapability::LocalExactReplay => { 501 SigningReplay::LocalReplaySafe 502 } 503 Some(ReplayCapability::NonReplayable) => SigningReplay::NonReplayable, 504 Some(ReplayCapability::ExactReplayByRequestId) => SigningReplay::ExactReplayByRequestId, 505 _ => return Err(OperationError::UnsupportedOperation), 506 }; 507 let mut routes = Vec::with_capacity(2); 508 for recipient in rumor.recipients() { 509 let route = self 510 .io 511 .route(*recipient, call(original)?.deadline_unix_ms()) 512 .await?; 513 self.io.targets(&route)?; 514 routes.push(route); 515 } 516 let mut seals = Vec::with_capacity(2); 517 for recipient in rumor.recipients() { 518 let plaintext = PrivateText::new(rumor.protected_wire()) 519 .map_err(|_| OperationError::InvalidCommand)?; 520 let ciphertext = signer 521 .encrypt_private(call(original)?, *recipient, plaintext) 522 .await 523 .map_err(|_| OperationError::Unauthorized)?; 524 seals.push( 525 CommerceSeal::new( 526 original.attempt().operation_id(), 527 original.attempt().command_digest(), 528 rumor, 529 *recipient, 530 self.io.seal_time(now)?, 531 ciphertext.as_str(), 532 ) 533 .map_err(|_| OperationError::InvalidEvidence)?, 534 ); 535 } 536 let plan = CommerceSigningPlan::new( 537 original.attempt().operation_id(), 538 original.attempt().command_digest(), 539 rumor, 540 seals 541 .try_into() 542 .map_err(|_| OperationError::RecoveryRequired)?, 543 routes 544 .try_into() 545 .map_err(|_| OperationError::RecoveryRequired)?, 546 replay, 547 ) 548 .map_err(|_| OperationError::InvalidEvidence)?; 549 signer 550 .verify_commerce_plan(call(original)?, rumor, plan) 551 .await 552 .map_err(|_| OperationError::InvalidEvidence) 553 } 554 }