native_commerce_tests.rs (52832B)
1 //! Real facade, SQLx and local crypto with explicitly controlled command IO. 2 //! Delivery cases additionally exercise explicit loopback Nostr transport. 3 //! Host custody and live route discovery remain outside these fixtures. 4 use super::{Client, NativeConfig, StartMode}; 5 use radroots_domain::{CommandContextData, OperationId, PoolId, PublicKey, UnixSeconds}; 6 use radroots_execution::{ 7 session::{ 8 HostFuture, 9 command::{CommandIo, CommandRuntime, capture_dm_route, selected_dm_targets}, 10 }, 11 workspace::CommandContext, 12 }; 13 use radroots_nostr::{key::SecretKey, public_ingress::ObservedHead, signing::LocalSigner}; 14 use radroots_protocol::{ 15 command::{AcceptOrderInput, AllocationSelection, CapturedOrderAcceptance}, 16 nip59::CapturedDmRoute, 17 }; 18 use radroots_secrets::{ 19 SecretId, SecretRef, 20 envelope::Nonce, 21 file::{FileOpenMode, FileProvider}, 22 id::{BackendKind, KeyVersion}, 23 provider::AccessPolicy, 24 wrapping::SecretMaterial, 25 }; 26 use radroots_signing::{ 27 SignReceipt, SignRequest, Signer, SignerStatus, 28 issuance::{ 29 ExactRecoveryCapability, ExactRecoveryOutcome, ExactRecoveryRequest, SigningIntent, 30 SigningOutcome, 31 }, 32 provider::{ 33 ParticipantProvider, PrivateCiphertext, PrivateText, ProviderCall, ProviderError, 34 ProviderState, SignerCallbacks, SignerHandle, 35 }, 36 signer::BoxFuture, 37 }; 38 use radroots_storage::{ 39 command::{OperationError, PrivateEnvelopeCandidate}, 40 event::SourceGeneration, 41 inventory::{InventoryCheckpointRef, InventoryOutcome, InventoryRequest, InventoryStore}, 42 workspace::{ 43 AttachmentProof, WorkspaceClock, WorkspaceError, 44 seller_stock::{ 45 SellerAuthoritySelection, StockGrantScope, StockListingCheckpointRef, StockResources, 46 StockSourceCheckpointRef, 47 }, 48 }, 49 }; 50 use radroots_storage_sqlite::{ 51 OpenMode, OpenOptions, Paths, 52 workspace::{ 53 NativeWorkspace, SellerStockConfig, StockConsentCapture, StockConsentMode, StockEnrollment, 54 StockGrantEnrollment, StockListingCapture, StockRequestSnapshot, StockSnapshotRequest, 55 StockSourceCapture, WorkspaceCrypto, 56 }, 57 }; 58 use radroots_transport::{Target, TargetSet}; 59 use std::{ 60 num::NonZeroU64, 61 sync::{ 62 Arc, Weak, 63 atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}, 64 }, 65 }; 66 67 fn data() -> serde_json::Value { 68 serde_json::from_str(include_str!( 69 "../tests/fixtures/ordinary_acceptance/inputs.v1.json" 70 )) 71 .unwrap() 72 } 73 fn proof(value: &AttachmentProof) -> AttachmentProof { 74 value 75 .with_secret(|b| AttachmentProof::from_protected_input(b)) 76 .unwrap() 77 } 78 struct Clock(AtomicU64, AtomicBool); 79 impl Clock { 80 fn enable_realtime(&self) { 81 self.1.store(true, Ordering::SeqCst); 82 } 83 } 84 impl WorkspaceClock for Clock { 85 fn now(&self) -> Result<UnixSeconds, WorkspaceError> { 86 let seconds = if self.1.load(Ordering::SeqCst) { 87 std::time::SystemTime::now() 88 .duration_since(std::time::UNIX_EPOCH) 89 .map_err(|_| WorkspaceError::Unavailable)? 90 .as_secs() 91 } else { 92 self.0.load(Ordering::SeqCst) 93 }; 94 UnixSeconds::new(seconds).map_err(|_| WorkspaceError::Unavailable) 95 } 96 } 97 struct Control { 98 pause_refused: AtomicBool, 99 pause_rejected: AtomicBool, 100 tamper_recovery: AtomicBool, 101 tamper_self: AtomicBool, 102 rejected: std::sync::Mutex<Option<radroots_signing::issuance::RejectedArtifact>>, 103 recovery_supported: AtomicBool, 104 signs: AtomicUsize, 105 recoveries: AtomicUsize, 106 fail_self: AtomicBool, 107 fail_peer: AtomicBool, 108 pause_peer: AtomicBool, 109 entered: tokio::sync::Notify, 110 release: tokio::sync::Notify, 111 } 112 impl Control { 113 fn new() -> Self { 114 Self { 115 pause_refused: AtomicBool::new(false), 116 pause_rejected: AtomicBool::new(false), 117 tamper_recovery: AtomicBool::new(false), 118 tamper_self: AtomicBool::new(false), 119 rejected: std::sync::Mutex::new(None), 120 recovery_supported: AtomicBool::new(true), 121 signs: AtomicUsize::new(0), 122 recoveries: AtomicUsize::new(0), 123 fail_self: AtomicBool::new(false), 124 fail_peer: AtomicBool::new(false), 125 pause_peer: AtomicBool::new(false), 126 entered: tokio::sync::Notify::new(), 127 release: tokio::sync::Notify::new(), 128 } 129 } 130 } 131 struct Provider { 132 inner: LocalSigner, 133 control: Arc<Control>, 134 } 135 impl Signer for Provider { 136 fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> { 137 self.inner.status() 138 } 139 fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> { 140 panic!("acceptance must never invoke legacy signing") 141 } 142 } 143 impl ParticipantProvider for Provider { 144 fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> { 145 Box::pin(async move { 146 let state = self.inner.provider_state().await?; 147 Ok(if self.control.recovery_supported.load(Ordering::SeqCst) { 148 state 149 } else { 150 state.with_exact_recovery(ExactRecoveryCapability::Unavailable) 151 }) 152 }) 153 } 154 fn encrypt_private( 155 &self, 156 c: ProviderCall, 157 p: PublicKey, 158 t: PrivateText, 159 ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> { 160 self.inner.encrypt_private(c, p, t) 161 } 162 fn decrypt_private( 163 &self, 164 c: ProviderCall, 165 p: PublicKey, 166 t: PrivateCiphertext, 167 ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> { 168 self.inner.decrypt_private(c, p, t) 169 } 170 fn sign_exact(&self, intent: SigningIntent) -> BoxFuture<'_, SigningOutcome> { 171 Box::pin(async move { 172 self.control.signs.fetch_add(1, Ordering::SeqCst); 173 let is_self = intent.recipient() == Some(self.inner.public_key()); 174 if (is_self && self.control.fail_self.load(Ordering::SeqCst)) 175 || (!is_self && self.control.fail_peer.load(Ordering::SeqCst)) 176 { 177 if self.control.pause_refused.swap(false, Ordering::SeqCst) { 178 self.control.entered.notify_one(); 179 self.control.release.notified().await; 180 } 181 return SigningOutcome::not_dispatched(intent.binding(), ProviderError::Cancelled); 182 } 183 let result = self.inner.sign_exact(intent).await; 184 if is_self && self.control.tamper_self.load(Ordering::SeqCst) { 185 let foreign = radroots_signing::issuance::IntentBinding::from_components( 186 OperationId::from_bytes([0xa1; 32]), 187 [0xa2; 32], 188 [0xa3; 32], 189 radroots_signing::issuance::ArtifactRole::BusinessSeal, 190 Some(self.inner.public_key()), 191 NonZeroU64::new(230000).unwrap(), 192 ) 193 .unwrap(); 194 let rejected = result.enforce_binding(foreign); 195 let radroots_signing::issuance::OutcomeKind::Rejected(metadata) = rejected.kind() 196 else { 197 panic!("actual artifact must retain bounded mismatch metadata") 198 }; 199 *self.control.rejected.lock().unwrap() = Some(*metadata); 200 if self.control.pause_rejected.swap(false, Ordering::SeqCst) { 201 self.control.entered.notify_one(); 202 self.control.release.notified().await; 203 } 204 return rejected; 205 } 206 if !is_self && self.control.pause_peer.swap(false, Ordering::SeqCst) { 207 self.control.entered.notify_one(); 208 self.control.release.notified().await; 209 } 210 result 211 }) 212 } 213 fn recover_exact(&self, request: ExactRecoveryRequest) -> BoxFuture<'_, ExactRecoveryOutcome> { 214 Box::pin(async move { 215 self.control.recoveries.fetch_add(1, Ordering::SeqCst); 216 let result = self.inner.recover_exact(request).await; 217 if self.control.tamper_recovery.load(Ordering::SeqCst) { 218 let foreign = radroots_signing::issuance::IntentBinding::from_components( 219 OperationId::from_bytes([0xa1; 32]), 220 [0xa2; 32], 221 [0xa3; 32], 222 radroots_signing::issuance::ArtifactRole::BusinessSeal, 223 Some(self.inner.public_key()), 224 NonZeroU64::new(230000).unwrap(), 225 ) 226 .unwrap(); 227 let rejected = result.enforce_binding(foreign); 228 let radroots_signing::issuance::ExactRecoveryKind::Rejected(metadata) = 229 rejected.kind() 230 else { 231 panic!("actual recovered artifact must retain bounded mismatch metadata") 232 }; 233 *self.control.rejected.lock().unwrap() = Some(*metadata); 234 return rejected; 235 } 236 result 237 }) 238 } 239 } 240 struct Callbacks; 241 impl SignerCallbacks for Callbacks { 242 fn quiesce(&self) -> BoxFuture<'_, Result<(), ProviderError>> { 243 Box::pin(async { Ok(()) }) 244 } 245 fn close(&self) -> BoxFuture<'_, Result<(), ProviderError>> { 246 Box::pin(async { Ok(()) }) 247 } 248 } 249 struct Io { 250 clock: Arc<Clock>, 251 next: AtomicUsize, 252 wraps: AtomicUsize, 253 sent: std::sync::Mutex<Vec<String>>, 254 missing_ack: AtomicBool, 255 pause_delivery: AtomicBool, 256 entered: tokio::sync::Notify, 257 release: tokio::sync::Notify, 258 route_override: Option<Vec<String>>, 259 transport: std::sync::Mutex<Option<Arc<radroots_transport_nostr::NostrTransport>>>, 260 } 261 impl Io { 262 fn new(clock: Arc<Clock>) -> Self { 263 Self { 264 clock, 265 next: AtomicUsize::new(1), 266 wraps: AtomicUsize::new(0), 267 sent: std::sync::Mutex::new(Vec::new()), 268 missing_ack: AtomicBool::new(false), 269 pause_delivery: AtomicBool::new(false), 270 entered: tokio::sync::Notify::new(), 271 release: tokio::sync::Notify::new(), 272 route_override: None, 273 transport: std::sync::Mutex::new(None), 274 } 275 } 276 fn selected(&self) -> TargetSet { 277 self.route_override.as_ref().map_or_else(targets, |uris| { 278 TargetSet::new( 279 uris.iter() 280 .map(|uri| Target::nostr_relay(uri).unwrap()) 281 .collect(), 282 ) 283 .unwrap() 284 }) 285 } 286 } 287 fn targets() -> TargetSet { 288 TargetSet::new(vec![Target::nostr_relay("wss://relay.example").unwrap()]).unwrap() 289 } 290 impl CommandIo for Io { 291 fn enabled(&self) -> bool { 292 true 293 } 294 fn now(&self) -> Result<UnixSeconds, OperationError> { 295 self.clock.now().map_err(Into::into) 296 } 297 fn seal_time(&self, now: UnixSeconds) -> Result<UnixSeconds, OperationError> { 298 Ok(now) 299 } 300 fn route( 301 &self, 302 recipient: PublicKey, 303 _: NonZeroU64, 304 ) -> HostFuture<'_, Result<CapturedDmRoute, OperationError>> { 305 Box::pin(async move { 306 if let Some(uris) = &self.route_override { 307 use nostr::JsonUtil; 308 let keys = [2, 3] 309 .into_iter() 310 .map(|scalar| { 311 nostr::Keys::new( 312 nostr::SecretKey::from_hex(&format!("{scalar:064x}")).unwrap(), 313 ) 314 }) 315 .find(|key| key.public_key().to_hex() == recipient.to_hex()) 316 .unwrap(); 317 let raw = nostr::EventBuilder::new(nostr::Kind::Custom(10050), "") 318 .tags( 319 uris.iter() 320 .map(|uri| nostr::Tag::parse(["relay", uri.as_str()]).unwrap()), 321 ) 322 .custom_created_at(nostr::Timestamp::from_secs(100)) 323 .sign_with_keys(&keys) 324 .unwrap() 325 .as_json(); 326 return capture_dm_route(recipient, [raw.as_str()], &self.selected()); 327 } 328 let value = data(); 329 let row = value["stock_routes"] 330 .as_array() 331 .unwrap() 332 .iter() 333 .find(|v| v["recipient"].as_str().unwrap() == recipient.to_hex()) 334 .unwrap(); 335 capture_dm_route(recipient, [row["raw"].as_str().unwrap()], &targets()) 336 }) 337 } 338 fn targets(&self, route: &CapturedDmRoute) -> Result<TargetSet, OperationError> { 339 selected_dm_targets(route, &self.selected()) 340 } 341 fn publication_policy(&self) -> radroots_transport::policy::SatisfactionPolicy { 342 use radroots_transport::policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}; 343 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()) 344 } 345 fn private_envelope( 346 &self, 347 recipient: PublicKey, 348 raw: &str, 349 ) -> Result<PrivateEnvelopeCandidate, OperationError> { 350 self.wraps.fetch_add(1, Ordering::SeqCst); 351 let wrapped = radroots_nostr::signing::gift_wrap::wrap_retained_seal( 352 raw, 353 recipient, 354 NonZeroU64::new(self.now()?.get()).unwrap(), 355 &radroots_nostr::signing::OsNonceSource, 356 ) 357 .map_err(|_| OperationError::InvalidEvidence)?; 358 wrapped.with_wrapping_key(|key| { 359 PrivateEnvelopeCandidate::from_obtained(recipient, wrapped.signed_json(), key) 360 }) 361 } 362 fn delivery_id(&self) -> Result<String, OperationError> { 363 Ok(format!("{:064x}", self.next.fetch_add(1, Ordering::SeqCst))) 364 } 365 fn publish( 366 &self, 367 request: radroots_transport::sink::DeliveryRequest, 368 selected: TargetSet, 369 ) -> HostFuture<'_, Result<radroots_transport::DeliveryReceipt, radroots_transport::SinkFailure>> 370 { 371 Box::pin(async move { 372 self.sent 373 .lock() 374 .unwrap() 375 .push(request.payload().event().raw_json().to_owned()); 376 if self.pause_delivery.swap(false, Ordering::SeqCst) { 377 self.entered.notify_one(); 378 self.release.notified().await; 379 } 380 let transport = self.transport.lock().unwrap().clone(); 381 if let Some(transport) = transport { 382 use radroots_transport::EventSink; 383 return transport.deliver_selected(request, selected).await; 384 } 385 use radroots_transport::{ 386 DeliveryReceipt, outcome::DeliveryOutcome, sink::DeliveryTargetReceipt, 387 }; 388 let outcome = if self.missing_ack.load(Ordering::SeqCst) { 389 DeliveryOutcome::unavailable() 390 } else { 391 DeliveryOutcome::accepted() 392 }; 393 Ok(DeliveryReceipt::for_request( 394 &request, 395 selected 396 .targets() 397 .iter() 398 .map(|target| DeliveryTargetReceipt::attempted(target.clone(), outcome.clone())) 399 .collect(), 400 ) 401 .unwrap()) 402 }) 403 } 404 } 405 struct Rig { 406 vault: Arc<FileProvider>, 407 _temp: tempfile::TempDir, 408 client: Client, 409 native: NativeWorkspace, 410 enrollment: StockEnrollment, 411 scope: radroots_execution::workspace::WorkspaceSession, 412 clock: Arc<Clock>, 413 control: Arc<Control>, 414 provider: Weak<Provider>, 415 io: Arc<Io>, 416 } 417 impl Rig { 418 async fn new() -> Self { 419 Self::configured(None, 300).await 420 } 421 async fn configured(route: Option<Vec<String>>, expiry: u64) -> Self { 422 let temp = tempfile::tempdir().unwrap(); 423 let root = temp.path().canonicalize().unwrap(); 424 let vault = Arc::new( 425 FileProvider::open( 426 root.join("vault"), 427 FileOpenMode::CreateNew, 428 SecretMaterial::from_slice(&[0xa5; 32]).unwrap(), 429 ) 430 .unwrap(), 431 ); 432 let reference = SecretRef::new( 433 SecretId::parse("workspace-key").unwrap(), 434 BackendKind::File, 435 KeyVersion::new(1).unwrap(), 436 ); 437 vault 438 .provision( 439 &reference, 440 &SecretMaterial::from_slice(&[0x41; 32]).unwrap(), 441 Nonce::new([0x11; 24]), 442 ) 443 .unwrap(); 444 let crypto = WorkspaceCrypto::new( 445 vault.clone(), 446 reference, 447 SecretMaterial::from_slice(&[0x41; 32]).unwrap(), 448 AccessPolicy::standard(), 449 ) 450 .unwrap(); 451 let clock = Arc::new(Clock(AtomicU64::new(150), AtomicBool::new(false))); 452 let control = Arc::new(Control::new()); 453 let provider = Arc::new(Provider { 454 inner: LocalSigner::with_clock( 455 SecretKey::parse(&format!("{:064x}", 3)).unwrap(), 456 || Ok(150000), 457 ) 458 .unwrap() 459 .with_nonce_source(Arc::new(radroots_nostr::signing::OsNonceSource)), 460 control: control.clone(), 461 }); 462 let key = provider.inner.public_key(); 463 assert_eq!(key.to_hex(), data()["scope"]["seller"].as_str().unwrap()); 464 let enrollment = StockEnrollment::prepare( 465 SellerStockConfig::new( 466 key, 467 key, 468 "synthetic-ordinary-acceptance", 469 UnixSeconds::new(expiry).unwrap(), 470 ) 471 .unwrap(), 472 clock.as_ref(), 473 ) 474 .unwrap(); 475 let native = NativeWorkspace::initialize_seller_stock( 476 &root.join("stock"), 477 &enrollment, 478 crypto, 479 clock.clone(), 480 ) 481 .await 482 .unwrap(); 483 std::fs::create_dir(root.join("cache")).unwrap(); 484 let options = OpenOptions::new( 485 Paths::from_directory(root.join("cache")).unwrap(), 486 OpenMode::Create, 487 ) 488 .with_source_generation(SourceGeneration::new([17; 32]).unwrap(), 1) 489 .unwrap(); 490 let mut client = 491 Client::open(NativeConfig::public_read(options).with_workspace(native.clone())) 492 .await 493 .unwrap(); 494 // Only IO is controlled. This preserves the actual client task host, 495 // attached scopes, stock evidence owner and concrete native adapter. 496 let mut io = Io::new(clock.clone()); 497 io.route_override = route; 498 let io = Arc::new(io); 499 client.session = client 500 .session 501 .clone() 502 .with_command_runtime(Arc::new(CommandRuntime::new(io.clone()))); 503 let scope = client 504 .attach(enrollment.input().clone(), proof(enrollment.proof())) 505 .await 506 .unwrap(); 507 let weak = Arc::downgrade(&provider); 508 client 509 .attach_signer(SignerHandle::new(provider, Arc::new(Callbacks))) 510 .await 511 .unwrap(); 512 client.start(StartMode::LocalOnly).await.unwrap(); 513 let rig = Self { 514 vault, 515 _temp: temp, 516 client, 517 native, 518 enrollment, 519 scope, 520 clock, 521 control, 522 provider: weak, 523 io, 524 }; 525 rig.seed().await; 526 rig 527 } 528 async fn minima( 529 &self, 530 ) -> ( 531 StockSourceCheckpointRef, 532 StockListingCheckpointRef, 533 InventoryCheckpointRef, 534 ) { 535 let current = self 536 .native 537 .stock_authority(self.enrollment.input().clone(), self.enrollment.proof()) 538 .await 539 .unwrap(); 540 ( 541 current.source_checkpoint().unwrap(), 542 current.listing_checkpoint().unwrap(), 543 current.inventory_checkpoint().unwrap(), 544 ) 545 } 546 fn context(&self, id: u8) -> CommandContextData { 547 self.scope 548 .command_context( 549 OperationId::from_bytes([id; 32]), 550 None, 551 None, 552 UnixSeconds::new(230).unwrap(), 553 ) 554 .unwrap() 555 .data() 556 .clone() 557 } 558 async fn seed(&self) { 559 let value = data(); 560 let key = self.enrollment.input().participant(); 561 let raw = value["listing_raw"].as_str().unwrap(); 562 let listing: serde_json::Value = serde_json::from_str(raw).unwrap(); 563 let d = listing["tags"] 564 .as_array() 565 .unwrap() 566 .iter() 567 .find(|v| v[0] == "d") 568 .unwrap()[1] 569 .as_str() 570 .unwrap(); 571 let mut head = ObservedHead::listing(key, d).unwrap(); 572 head.observe(raw).unwrap(); 573 let capture = StockListingCapture::prepare( 574 SellerAuthoritySelection::from_attachment(self.enrollment.input()), 575 &head, 576 ) 577 .unwrap(); 578 let (_, minimum, _) = self.minima().await; 579 self.native 580 .retain_stock_listing( 581 self.scope.binding().clone(), 582 minimum, 583 &capture, 584 self.enrollment.proof(), 585 ) 586 .await 587 .unwrap(); 588 for row in value["sources"].as_array().unwrap() { 589 let local = LocalSigner::with_clock( 590 SecretKey::parse(&format!( 591 "{:064x}", 592 row["recipient_scalar"].as_u64().unwrap() 593 )) 594 .unwrap(), 595 || Ok(1000), 596 ) 597 .unwrap(); 598 let call = ProviderCall::new( 599 local.public_key(), 600 NonZeroU64::new(2000).unwrap(), 601 radroots_signing::request::CancellationSignal::new(), 602 ); 603 let opened = 604 radroots_nostr::commerce::open(&local, call, row["raw_wrap"].as_str().unwrap()) 605 .await 606 .unwrap(); 607 let capture = StockSourceCapture::prepare( 608 SellerAuthoritySelection::from_attachment(self.enrollment.input()), 609 &opened, 610 ) 611 .unwrap(); 612 let (minimum, _, _) = self.minima().await; 613 self.native 614 .retain_stock_source( 615 self.scope.binding().clone(), 616 minimum, 617 &capture, 618 self.enrollment.proof(), 619 ) 620 .await 621 .unwrap(); 622 } 623 let snapshot = self.request().await; 624 let line = &snapshot.terms().lines()[0]; 625 for (id, wire) in [ 626 ( 627 80, 628 serde_json::json!({"type":"stock.create_pool","context":self.context(80),"input":{"id":PoolId::from_bytes([80;32]),"label":"private test stock","unit":"each","tick_scale":"0","initial_quantity":"10"}}), 629 ), 630 ( 631 81, 632 serde_json::json!({"type":"stock.map_option","context":self.context(81),"input":{"listing":line.source().coordinate(),"option_id":line.option_id(),"pool_id":PoolId::from_bytes([80;32]),"expected_mapping_version":"0","per_sale_unit":{"amount":"1","unit":"each"}}}), 633 ), 634 ] { 635 assert_eq!( 636 wire["context"]["operation_id"], 637 serde_json::to_value(OperationId::from_bytes([id; 32])).unwrap() 638 ); 639 let (_, _, minimum) = self.minima().await; 640 let request = InventoryRequest::from_protected_wire( 641 self.scope.binding().clone(), 642 minimum, 643 &serde_json::to_vec(&wire).unwrap(), 644 ) 645 .unwrap(); 646 assert!(matches!( 647 self.native 648 .execute_inventory(request, proof(self.enrollment.proof())) 649 .await 650 .unwrap(), 651 InventoryOutcome::Committed(_) 652 )); 653 } 654 } 655 async fn request(&self) -> StockRequestSnapshot { 656 let (private, public, minimum) = self.minima().await; 657 self.native 658 .stock_order_request( 659 self.scope.binding().clone(), 660 minimum, 661 private, 662 public, 663 data()["request"].as_str().unwrap().parse().unwrap(), 664 self.enrollment.proof(), 665 ) 666 .await 667 .unwrap() 668 } 669 async fn captured(&self) -> (CapturedOrderAcceptance, CommandContext) { 670 let snapshot = self.request().await; 671 let mut value = serde_json::json!({"type":"orders.accept","context":self.context(90),"input":{"request":snapshot.request(),"terms_digest":snapshot.terms_digest(),"allocation":{"type":"automatic"}}}); 672 value["context"]["expected"] = serde_json::json!({"agreement":null,"buyer_head":snapshot.request(),"checkpoint":snapshot.checkpoint(),"order_id":snapshot.scope().order_id(),"seller_sequence":"0"}); 673 let first = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap(); 674 value["context"]["approval"] = serde_json::json!({"intent_digest":first.approval_intent_digest(),"scope":"orders.accept","expires_at":"230"}); 675 let command = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap(); 676 let context = self 677 .scope 678 .command_context( 679 command.context().operation_id(), 680 command.context().expected().cloned(), 681 command.context().approval().cloned(), 682 UnixSeconds::new(230).unwrap(), 683 ) 684 .unwrap(); 685 let capture = StockConsentCapture::prepare( 686 SellerAuthoritySelection::from_attachment(self.enrollment.input()), 687 self.enrollment.input().grant_id(), 688 StockConsentMode::ExecuteAndRecover, 689 StockResources::all_pools(), 690 UnixSeconds::new(230).unwrap(), 691 CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), 692 ) 693 .unwrap(); 694 let (_, _, minimum) = self.minima().await; 695 self.native 696 .issue_stock_consent( 697 self.scope.binding().clone(), 698 minimum, 699 &capture, 700 self.enrollment.proof(), 701 ) 702 .await 703 .unwrap(); 704 (command, context) 705 } 706 async fn accept(&self) -> (CapturedOrderAcceptance, crate::orders::AcceptanceStatus) { 707 let (command, context) = self.captured().await; 708 let (private, public, minimum) = self.minima().await; 709 let input = AcceptOrderInput::new( 710 command.input().request(), 711 command.input().terms_digest(), 712 AllocationSelection::automatic(), 713 ); 714 let status = self 715 .client 716 .orders(&self.scope) 717 .accept(context, minimum, private, public, input) 718 .await 719 .unwrap(); 720 (command, status) 721 } 722 } 723 724 #[tokio::test] 725 async fn ordinary_acceptance_uses_real_t0_t1_s_t2_and_preserves_original_retry() { 726 let r = Rig::new().await; 727 let (command, status) = r.accept().await; 728 assert!(status.installation().is_some()); 729 assert!(status.recipients().iter().all(|v| v.evidence.is_some())); 730 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 731 assert_eq!(r.io.sent.lock().unwrap().len(), 2); 732 let (_, _, minimum) = r.minima().await; 733 let observed = r 734 .client 735 .orders(&r.scope) 736 .acceptance_status(minimum, command.context().operation_id(), command.digest()) 737 .await 738 .unwrap(); 739 assert_eq!(observed.installation(), status.installation()); 740 // Actual protected stock delivery uses controlled transport outcomes here. 741 // S remains independently readable through the same native owner. 742 assert!(observed.delivery().unwrap().iter().all(|value| { 743 value.checkpoint() == observed.checkpoint() 744 && value.source().is_some() 745 && value.attempt_count() == 1 746 && value.acceptance_satisfied().unwrap() 747 })); 748 let evidence = observed.recipients()[0].evidence.unwrap(); 749 let source = radroots_execution::session::commerce::AcceptanceStore::signing_evidence( 750 &crate::native_commerce::NativeCommerce(Arc::new(r.native.clone())), 751 radroots_execution::session::commerce::AcceptanceSelection { 752 binding: r.scope.binding().clone(), 753 minimum, 754 operation: command.context().operation_id(), 755 digest: command.digest(), 756 }, 757 evidence, 758 r.enrollment.proof(), 759 ) 760 .await 761 .unwrap() 762 .unwrap(); 763 assert_eq!(source.receipt(), evidence); 764 source.with_json(|raw| { 765 assert_eq!( 766 serde_json::from_str::<serde_json::Value>(raw).unwrap()["kind"], 767 13 768 ) 769 }); 770 r.clock.0.store(231, Ordering::SeqCst); 771 let refused = r 772 .client 773 .orders(&r.scope) 774 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 775 .await 776 .unwrap_err(); 777 assert_eq!(refused.code(), crate::Code::DeadlineExceeded); 778 // Expired issuing consent is not silently renewed. An actual authorized 779 // RecoverOnly replacement permits historical reads, never a new signature. 780 let child = StockGrantEnrollment::prepare( 781 &SellerAuthoritySelection::from_attachment(r.enrollment.input()), 782 "replacement recovery operator".into(), 783 UnixSeconds::new(290).unwrap(), 784 StockGrantScope::full_inventory(), 785 ) 786 .unwrap(); 787 r.native 788 .enroll_stock_grant( 789 r.scope.binding().clone(), 790 minimum, 791 r.enrollment.proof(), 792 &child, 793 ) 794 .await 795 .unwrap(); 796 let (_, _, minimum) = r.minima().await; 797 let capture = StockConsentCapture::prepare( 798 SellerAuthoritySelection::from_attachment(r.enrollment.input()), 799 child.input().grant_id(), 800 StockConsentMode::RecoverOnly, 801 StockResources::all_pools(), 802 UnixSeconds::new(280).unwrap(), 803 CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), 804 ) 805 .unwrap(); 806 r.native 807 .issue_stock_consent( 808 r.scope.binding().clone(), 809 minimum, 810 &capture, 811 r.enrollment.proof(), 812 ) 813 .await 814 .unwrap(); 815 let recovery_scope = r 816 .client 817 .attach(child.input().clone(), proof(child.proof())) 818 .await 819 .unwrap(); 820 let resumed = r 821 .client 822 .orders(&recovery_scope) 823 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 824 .await 825 .unwrap(); 826 assert_eq!(resumed.installation(), status.installation()); 827 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 828 assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); 829 r.client.close().await.unwrap(); 830 assert!(r.provider.upgrade().is_none()); 831 } 832 833 #[tokio::test] 834 async fn lost_observer_cannot_discard_actual_peer_artifact_and_close_installs_before_key_disposal() 835 { 836 let r = Rig::new().await; 837 r.control.pause_peer.store(true, Ordering::SeqCst); 838 let (command, context) = r.captured().await; 839 let (private, public, minimum) = r.minima().await; 840 let input = AcceptOrderInput::new( 841 command.input().request(), 842 command.input().terms_digest(), 843 AllocationSelection::automatic(), 844 ); 845 let client = r.client.clone(); 846 let scope = r.scope.clone(); 847 let waiter = tokio::spawn(async move { 848 client 849 .orders(&scope) 850 .accept(context, minimum, private, public, input) 851 .await 852 }); 853 tokio::time::timeout( 854 std::time::Duration::from_secs(20), 855 r.control.entered.notified(), 856 ) 857 .await 858 .unwrap(); 859 assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); 860 waiter.abort(); 861 assert!(waiter.await.unwrap_err().is_cancelled()); 862 let mut closing = Box::pin(r.client.close()); 863 assert!(futures::poll!(closing.as_mut()).is_pending()); 864 assert!(r.provider.upgrade().is_some()); 865 r.control.release.notify_one(); 866 closing.await.unwrap(); 867 assert!(r.provider.upgrade().is_none()); 868 let crypto = WorkspaceCrypto::new( 869 r.vault.clone(), 870 SecretRef::new( 871 SecretId::parse("workspace-key").unwrap(), 872 BackendKind::File, 873 KeyVersion::new(1).unwrap(), 874 ), 875 SecretMaterial::from_slice(&[0x41; 32]).unwrap(), 876 AccessPolicy::standard(), 877 ) 878 .unwrap(); 879 let reopened = NativeWorkspace::open_seller_stock( 880 &r._temp.path().join("stock"), 881 r.enrollment.input().clone(), 882 crypto, 883 r.clock.clone(), 884 ) 885 .await 886 .unwrap(); 887 let binding = reopened 888 .authenticate(r.enrollment.input().clone(), r.enrollment.proof()) 889 .await 890 .unwrap(); 891 let snapshot = reopened 892 .stock_operation_snapshot( 893 StockSnapshotRequest::new( 894 binding, 895 minimum, 896 command.context().operation_id(), 897 command.digest(), 898 ), 899 r.enrollment.proof(), 900 ) 901 .await 902 .unwrap(); 903 assert!(snapshot.installation().is_some()); 904 assert_eq!( 905 snapshot 906 .recipients() 907 .iter() 908 .filter(|v| v.first_evidence().is_some()) 909 .count(), 910 1 911 ); 912 assert_eq!( 913 snapshot.preparation().attempt().operation_id(), 914 command.context().operation_id() 915 ); 916 assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); 917 reopened.close().await.unwrap(); 918 } 919 920 #[path = "native_stock_delivery_tests.rs"] 921 mod delivery; 922 #[path = "native_refusal_tests.rs"] 923 mod original_refusals; 924 #[path = "native_stock_rewrap_tests.rs"] 925 mod rewrap; 926 927 #[path = "native_stock_deficit_tests.rs"] 928 mod deficit; 929 #[path = "native_stock_terms_tests.rs"] 930 mod terms; 931 932 #[tokio::test] 933 async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_recovery() { 934 let r = Rig::new().await; 935 r.control.fail_self.store(true, Ordering::SeqCst); 936 let (command, status) = r.accept().await; 937 let installation = status 938 .installation() 939 .expect("peer S must install before self refusal"); 940 assert_eq!( 941 status 942 .recipients() 943 .iter() 944 .filter(|v| v.evidence.is_some()) 945 .count(), 946 1 947 ); 948 assert!(!status.aborted()); 949 assert_eq!(r.io.sent.lock().unwrap().len(), 1); 950 for (delivery, recipient) in status.delivery().unwrap().iter().zip(status.recipients()) { 951 assert_eq!( 952 delivery.attempt_count(), 953 u16::from(recipient.evidence.is_some()) 954 ); 955 assert_eq!( 956 delivery.acceptance_satisfied().unwrap(), 957 recipient.evidence.is_some() 958 ); 959 } 960 let original_refusal = status 961 .recipients() 962 .iter() 963 .find_map(|v| v.original_unissued) 964 .expect("actual original refusal must be captured"); 965 assert_eq!(original_refusal.reason, ProviderError::Cancelled); 966 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 967 r.control.fail_self.store(false, Ordering::SeqCst); 968 let (_, _, minimum) = r.minima().await; 969 let resumed = r 970 .client 971 .orders(&r.scope) 972 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 973 .await 974 .unwrap(); 975 assert_eq!(resumed.installation(), Some(installation)); 976 assert!(resumed.recipients().iter().all(|v| v.evidence.is_some())); 977 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 978 assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1); 979 assert_eq!( 980 resumed 981 .recipients() 982 .iter() 983 .find_map(|v| v.original_unissued), 984 Some(original_refusal) 985 ); 986 r.client.close().await.unwrap(); 987 assert!(r.provider.upgrade().is_none()); 988 } 989 990 #[tokio::test] 991 async fn later_local_capability_cannot_upgrade_an_original_non_replayable_unknown_claim() { 992 let r = Rig::new().await; 993 r.control.recovery_supported.store(false, Ordering::SeqCst); 994 r.control.fail_self.store(true, Ordering::SeqCst); 995 let (command, status) = r.accept().await; 996 assert!(status.installation().is_some()); 997 r.control.fail_self.store(false, Ordering::SeqCst); 998 r.control.recovery_supported.store(true, Ordering::SeqCst); 999 let (_, _, minimum) = r.minima().await; 1000 let resumed = r 1001 .client 1002 .orders(&r.scope) 1003 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 1004 .await 1005 .unwrap(); 1006 assert_eq!(resumed.installation(), status.installation()); 1007 assert_eq!( 1008 resumed 1009 .recipients() 1010 .iter() 1011 .filter(|v| v.evidence.is_some()) 1012 .count(), 1013 1 1014 ); 1015 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 1016 assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); 1017 assert!(!resumed.aborted()); 1018 r.client.close().await.unwrap(); 1019 } 1020 1021 #[tokio::test] 1022 async fn actual_s_insert_failure_retains_obtained_peer_bytes_and_resumes_without_peer_reissue() { 1023 use sqlx::Connection; 1024 let r = Rig::new().await; 1025 r.control.pause_peer.store(true, Ordering::SeqCst); 1026 let (command, context) = r.captured().await; 1027 let (private, public, minimum) = r.minima().await; 1028 let input = AcceptOrderInput::new( 1029 command.input().request(), 1030 command.input().terms_digest(), 1031 AllocationSelection::automatic(), 1032 ); 1033 let client = r.client.clone(); 1034 let scope = r.scope.clone(); 1035 let waiter = tokio::spawn(async move { 1036 client 1037 .orders(&scope) 1038 .accept(context, minimum, private, public, input) 1039 .await 1040 }); 1041 tokio::time::timeout( 1042 std::time::Duration::from_secs(20), 1043 r.control.entered.notified(), 1044 ) 1045 .await 1046 .unwrap(); 1047 // The real peer artifact already exists. Fail the actual SQL INSERT, 1048 // independently of Core's retained-material owner and transaction result. 1049 let path = r._temp.path().join("stock/stock_execution_v1.sqlite"); 1050 let mut fault = sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())) 1051 .await 1052 .unwrap(); 1053 sqlx::query("CREATE TRIGGER controlled_s_failure BEFORE INSERT ON stock_signing_evidence BEGIN SELECT RAISE(ABORT, 'controlled_s_failure'); END").execute(&mut fault).await.unwrap(); 1054 r.control.release.notify_one(); 1055 let error = waiter.await.unwrap().unwrap_err(); 1056 assert_eq!(error.code(), crate::Code::StorageFailure); 1057 assert_eq!(error.context().admission(), crate::Admission::Confirmed); 1058 assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); 1059 let context = r 1060 .scope 1061 .command_context( 1062 command.context().operation_id(), 1063 command.context().expected().cloned(), 1064 command.context().approval().cloned(), 1065 UnixSeconds::new(230).unwrap(), 1066 ) 1067 .unwrap(); 1068 let blocked = r 1069 .client 1070 .orders(&r.scope) 1071 .accept( 1072 context, 1073 minimum, 1074 private, 1075 public, 1076 AcceptOrderInput::new( 1077 command.input().request(), 1078 command.input().terms_digest(), 1079 AllocationSelection::automatic(), 1080 ), 1081 ) 1082 .await 1083 .unwrap_err(); 1084 assert_eq!(blocked.code(), crate::Code::RecoveryRequired); 1085 assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); 1086 sqlx::query("DROP TRIGGER controlled_s_failure") 1087 .execute(&mut fault) 1088 .await 1089 .unwrap(); 1090 fault.close().await.unwrap(); 1091 r.client.stock(&r.scope).drain_evidence().await.unwrap(); 1092 let status = r 1093 .client 1094 .orders(&r.scope) 1095 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 1096 .await 1097 .unwrap(); 1098 assert!(status.installation().is_some()); 1099 assert!(status.recipients().iter().all(|v| v.evidence.is_some())); 1100 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 1101 assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); 1102 let pool = r 1103 .native 1104 .pool( 1105 r.scope.binding().clone(), 1106 status.checkpoint(), 1107 PoolId::from_bytes([80; 32]), 1108 proof(r.enrollment.proof()), 1109 ) 1110 .await 1111 .unwrap() 1112 .unwrap(); 1113 assert_eq!(pool.snapshot().balances().physical().available.get(), 7); 1114 assert_eq!( 1115 pool.snapshot().balances().physical().preparatory_hold.get(), 1116 0 1117 ); 1118 assert_eq!( 1119 pool.snapshot().balances().physical().committed_hold.get(), 1120 3 1121 ); 1122 r.client.close().await.unwrap(); 1123 assert!(r.provider.upgrade().is_none()); 1124 } 1125 1126 #[tokio::test] 1127 async fn identical_authenticated_foreign_scope_cannot_start_this_clients_acceptance() { 1128 let r = Rig::new().await; 1129 let (command, _) = r.captured().await; 1130 let (private, public, minimum) = r.minima().await; 1131 let path = r._temp.path().join("other_cache"); 1132 std::fs::create_dir(&path).unwrap(); 1133 let options = OpenOptions::new(Paths::from_directory(path).unwrap(), OpenMode::Create) 1134 .with_source_generation(SourceGeneration::new([19; 32]).unwrap(), 1) 1135 .unwrap(); 1136 let other = Client::open(NativeConfig::public_read(options).with_workspace(r.native.clone())) 1137 .await 1138 .unwrap(); 1139 let foreign = other 1140 .attach(r.enrollment.input().clone(), proof(r.enrollment.proof())) 1141 .await 1142 .unwrap(); 1143 assert_eq!(foreign.binding().input(), r.scope.binding().input()); 1144 let context = foreign 1145 .command_context( 1146 command.context().operation_id(), 1147 command.context().expected().cloned(), 1148 command.context().approval().cloned(), 1149 UnixSeconds::new(230).unwrap(), 1150 ) 1151 .unwrap(); 1152 assert_eq!(context.data(), command.context()); 1153 let error = r 1154 .client 1155 .orders(&foreign) 1156 .accept( 1157 context, 1158 minimum, 1159 private, 1160 public, 1161 AcceptOrderInput::new( 1162 command.input().request(), 1163 command.input().terms_digest(), 1164 AllocationSelection::automatic(), 1165 ), 1166 ) 1167 .await 1168 .unwrap_err(); 1169 assert_eq!(error.code(), crate::Code::Unauthorized); 1170 assert_eq!(error.context().admission(), crate::Admission::NotAdmitted); 1171 assert_eq!(r.minima().await.2, minimum); 1172 assert_eq!(r.control.signs.load(Ordering::SeqCst), 0); 1173 r.client.close().await.unwrap(); 1174 other.close().await.unwrap(); 1175 } 1176 1177 fn assert_rejected(error: crate::ExecutionFailure, operation: OperationId, control: &Control) { 1178 assert_eq!(error.code(), crate::Code::SignerTampering); 1179 assert_eq!(error.context().operation_id(), Some(operation)); 1180 assert_eq!(error.context().admission(), crate::Admission::Confirmed); 1181 assert_eq!(error.retry(), crate::RetryClass::ManualReconciliation); 1182 let rejected = error 1183 .signer_rejection() 1184 .expect("preserve the actual bounded rejection"); 1185 assert_eq!( 1186 rejected, 1187 *control.rejected.lock().unwrap().as_ref().unwrap() 1188 ); 1189 let fingerprint = rejected 1190 .fingerprint() 1191 .expect("actual returned bytes have fingerprint coverage"); 1192 assert!(fingerprint.covered_bytes() > 0); 1193 assert_eq!(fingerprint.covered_bytes(), fingerprint.total_bytes()); 1194 assert!(fingerprint.covered_bytes() <= 65536); 1195 } 1196 1197 #[tokio::test] 1198 async fn rejected_self_callback_returns_bounded_tampering_without_losing_peer_installation() { 1199 let r = Rig::new().await; 1200 r.control.tamper_self.store(true, Ordering::SeqCst); 1201 let (command, context) = r.captured().await; 1202 let (private, public, minimum) = r.minima().await; 1203 let error = r 1204 .client 1205 .orders(&r.scope) 1206 .accept( 1207 context, 1208 minimum, 1209 private, 1210 public, 1211 AcceptOrderInput::new( 1212 command.input().request(), 1213 command.input().terms_digest(), 1214 AllocationSelection::automatic(), 1215 ), 1216 ) 1217 .await 1218 .unwrap_err(); 1219 assert_rejected(error, command.context().operation_id(), &r.control); 1220 let status = r 1221 .client 1222 .orders(&r.scope) 1223 .acceptance_status(minimum, command.context().operation_id(), command.digest()) 1224 .await 1225 .unwrap(); 1226 let installed = status 1227 .installation() 1228 .expect("actual peer S installs before self rejection"); 1229 assert_eq!( 1230 status 1231 .recipients() 1232 .iter() 1233 .filter(|v| v.evidence.is_some()) 1234 .count(), 1235 1 1236 ); 1237 assert!(!status.aborted()); 1238 assert_eq!(r.io.sent.lock().unwrap().len(), 1); 1239 for (delivery, recipient) in status.delivery().unwrap().iter().zip(status.recipients()) { 1240 assert_eq!( 1241 delivery.attempt_count(), 1242 u16::from(recipient.evidence.is_some()) 1243 ); 1244 assert_eq!( 1245 delivery.acceptance_satisfied().unwrap(), 1246 recipient.evidence.is_some() 1247 ); 1248 } 1249 r.control.tamper_self.store(false, Ordering::SeqCst); 1250 let resumed = r 1251 .client 1252 .orders(&r.scope) 1253 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 1254 .await 1255 .unwrap(); 1256 assert_eq!(resumed.installation(), Some(installed)); 1257 assert!(resumed.recipients().iter().all(|v| v.evidence.is_some())); 1258 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 1259 assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1); 1260 r.client.close().await.unwrap(); 1261 assert!(r.provider.upgrade().is_none()); 1262 } 1263 1264 #[tokio::test] 1265 async fn generic_inquiry_installs_actual_peer_and_returns_original_bounded_self_rejection() { 1266 for fail_install in [false, true] { 1267 let r = Rig::new().await; 1268 r.control 1269 .pause_rejected 1270 .store(fail_install, Ordering::SeqCst); 1271 r.control.tamper_self.store(true, Ordering::SeqCst); 1272 let crypto = WorkspaceCrypto::new( 1273 r.vault.clone(), 1274 SecretRef::new( 1275 SecretId::parse("workspace-key").unwrap(), 1276 BackendKind::File, 1277 KeyVersion::new(1).unwrap(), 1278 ), 1279 SecretMaterial::from_slice(&[0x41; 32]).unwrap(), 1280 AccessPolicy::standard(), 1281 ) 1282 .unwrap(); 1283 let key = r.enrollment.input().participant(); 1284 let (native, input, credential) = NativeWorkspace::initialize_local_outbox( 1285 &r._temp.path().join("chat"), 1286 radroots_storage_sqlite::workspace::LocalOutboxConfig::new( 1287 key, 1288 key, 1289 "synthetic-rejected-chat", 1290 UnixSeconds::new(300).unwrap(), 1291 ) 1292 .unwrap(), 1293 crypto, 1294 r.clock.clone(), 1295 ) 1296 .await 1297 .unwrap(); 1298 let path = r._temp.path().join("chat_cache"); 1299 std::fs::create_dir(&path).unwrap(); 1300 let options = OpenOptions::new(Paths::from_directory(path).unwrap(), OpenMode::Create) 1301 .with_source_generation(SourceGeneration::new([20; 32]).unwrap(), 1) 1302 .unwrap(); 1303 let mut client = Client::open(NativeConfig::public_read(options).with_workspace(native)) 1304 .await 1305 .unwrap(); 1306 client.session = 1307 client 1308 .session 1309 .clone() 1310 .with_command_runtime(Arc::new(CommandRuntime::new(Arc::new(Io::new( 1311 r.clock.clone(), 1312 ))))); 1313 let scope = client.attach(input, proof(&credential)).await.unwrap(); 1314 client 1315 .attach_signer(SignerHandle::new( 1316 r.provider.upgrade().unwrap(), 1317 Arc::new(Callbacks), 1318 )) 1319 .await 1320 .unwrap(); 1321 client.start(StartMode::LocalOnly).await.unwrap(); 1322 let operation = OperationId::from_bytes([95; 32]); 1323 let context = scope 1324 .command_context(operation, None, None, UnixSeconds::new(230).unwrap()) 1325 .unwrap(); 1326 let peer = data()["scope"]["buyer"].as_str().unwrap().parse().unwrap(); 1327 let input = crate::inbox::InquireInput::new( 1328 radroots_domain::ThreadId::from_bytes([96; 32]), 1329 peer, 1330 None, 1331 "synthetic private inquiry", 1332 ) 1333 .unwrap(); 1334 let observer_client = client.clone(); 1335 let observer = 1336 tokio::spawn(async move { observer_client.inbox().inquire(context, input).await }); 1337 let mut injected = None; 1338 if fail_install { 1339 use sqlx::Connection; 1340 tokio::time::timeout( 1341 std::time::Duration::from_secs(20), 1342 r.control.entered.notified(), 1343 ) 1344 .await 1345 .unwrap(); 1346 let path = r._temp.path().join("chat/execution_v1.sqlite"); 1347 let mut connection = 1348 sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())) 1349 .await 1350 .unwrap(); 1351 sqlx::query("CREATE TRIGGER controlled_t2_failure BEFORE INSERT ON chat_messages BEGIN SELECT RAISE(ABORT, 'controlled_t2_failure'); END").execute(&mut connection).await.unwrap(); 1352 injected = Some(connection); 1353 r.control.release.notify_one(); 1354 } 1355 let error = observer.await.unwrap().unwrap_err(); 1356 if fail_install { 1357 assert_eq!(error.code(), crate::Code::StorageFailure); 1358 assert_eq!(error.context().operation_id(), Some(operation)); 1359 assert_eq!(error.context().admission(), crate::Admission::Confirmed); 1360 assert_eq!(error.retry(), crate::RetryClass::ManualReconciliation); 1361 assert_eq!( 1362 error.signer_rejection(), 1363 *r.control.rejected.lock().unwrap() 1364 ); 1365 } else { 1366 assert_rejected(error, operation, &r.control) 1367 } 1368 if let Some(mut connection) = injected { 1369 use sqlx::Connection; 1370 sqlx::query("DROP TRIGGER controlled_t2_failure") 1371 .execute(&mut connection) 1372 .await 1373 .unwrap(); 1374 connection.close().await.unwrap(); 1375 } 1376 let status = client 1377 .operations(&scope) 1378 .get(operation) 1379 .await 1380 .unwrap() 1381 .unwrap(); 1382 assert_eq!( 1383 status.business_installation(), 1384 if fail_install { 1385 crate::BusinessInstallation::NotInstalled 1386 } else { 1387 crate::BusinessInstallation::Installed 1388 } 1389 ); 1390 assert_eq!( 1391 status 1392 .artifacts() 1393 .iter() 1394 .filter(|v| v.issuance() == crate::Issuance::Obtained) 1395 .count(), 1396 1 1397 ); 1398 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 1399 client.close().await.unwrap(); 1400 r.client.close().await.unwrap(); 1401 assert!(r.provider.upgrade().is_none()); 1402 } 1403 } 1404 1405 #[tokio::test] 1406 async fn rejected_exact_recovery_keeps_original_binding_and_cannot_release_installed_peer() { 1407 let r = Rig::new().await; 1408 r.control.fail_self.store(true, Ordering::SeqCst); 1409 let (command, status) = r.accept().await; 1410 let installed = status.installation().unwrap(); 1411 r.control.fail_self.store(false, Ordering::SeqCst); 1412 r.control.tamper_recovery.store(true, Ordering::SeqCst); 1413 let (_, _, minimum) = r.minima().await; 1414 let error = r 1415 .client 1416 .orders(&r.scope) 1417 .resume_acceptance(minimum, command.context().operation_id(), command.digest()) 1418 .await 1419 .unwrap_err(); 1420 assert_rejected(error, command.context().operation_id(), &r.control); 1421 let current = r 1422 .client 1423 .orders(&r.scope) 1424 .acceptance_status(minimum, command.context().operation_id(), command.digest()) 1425 .await 1426 .unwrap(); 1427 assert_eq!(current.installation(), Some(installed)); 1428 assert_eq!( 1429 current 1430 .recipients() 1431 .iter() 1432 .filter(|v| v.evidence.is_some()) 1433 .count(), 1434 1 1435 ); 1436 assert!(!current.aborted()); 1437 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 1438 assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1); 1439 r.client.close().await.unwrap(); 1440 }