stock_source.rs (26834B)
1 use super::*; 2 use radroots_nostr::{commerce, key::SecretKey, signing::LocalSigner}; 3 use radroots_signing::{provider::ProviderCall, request::CancellationSignal}; 4 use radroots_storage::workspace::seller_stock::{ 5 SellerAuthoritySelection, StockSourceCheckpointRef, 6 }; 7 use radroots_storage_sqlite::workspace::{ 8 StockGrantEnrollment, StockGrantOutcome, StockSourceCapture, StockSourceOutcome, 9 StockSourceProfile, StockSourceReceipt, 10 }; 11 use serde::Deserialize; 12 use std::num::NonZeroU64; 13 14 #[path = "source_provider.rs"] 15 mod provider; 16 17 #[derive(Clone, Deserialize)] 18 struct Vector { 19 name: String, 20 recipient_scalar: u64, 21 raw_wrap: String, 22 raw_seal: String, 23 raw_rumor: String, 24 } 25 fn vectors() -> Vec<Vector> { 26 serde_json::from_str(include_str!("../fixtures/stock_sources.v1.json")).unwrap() 27 } 28 fn source_vector(name: &str) -> Vector { 29 vectors().into_iter().find(|row| row.name == name).unwrap() 30 } 31 fn signer(row: &Vector) -> LocalSigner { 32 LocalSigner::with_clock( 33 SecretKey::parse(&format!("{:064x}", row.recipient_scalar)).unwrap(), 34 || Ok(1000), 35 ) 36 .unwrap() 37 } 38 async fn capture(e: &StockEnrollment, row: &Vector) -> StockSourceCapture { 39 let signer = signer(row); 40 let call = ProviderCall::new( 41 signer.public_key(), 42 NonZeroU64::new(2000).unwrap(), 43 CancellationSignal::new(), 44 ); 45 let opened = commerce::open(&signer, call, &row.raw_wrap).await.unwrap(); 46 StockSourceCapture::prepare( 47 SellerAuthoritySelection::from_attachment(e.input()), 48 &opened, 49 ) 50 .unwrap() 51 } 52 async fn create_source( 53 f: &Fixture, 54 row: &Vector, 55 clock: Arc<dyn WorkspaceClock>, 56 ) -> ( 57 NativeWorkspace, 58 StockEnrollment, 59 radroots_storage::workspace::WorkspaceBinding, 60 ) { 61 let e = StockEnrollment::prepare( 62 SellerStockConfig::new( 63 signer(row).public_key(), 64 key(), 65 "source-owner", 66 UnixSeconds::new(200).unwrap(), 67 ) 68 .unwrap(), 69 clock.as_ref(), 70 ) 71 .unwrap(); 72 let store = NativeWorkspace::initialize_seller_stock(&f.path, &e, f.crypto(), clock) 73 .await 74 .unwrap(); 75 let binding = store 76 .authenticate(e.input().clone(), e.proof()) 77 .await 78 .unwrap(); 79 (store, e, binding) 80 } 81 async fn source_minimum(store: &NativeWorkspace, e: &StockEnrollment) -> StockSourceCheckpointRef { 82 store 83 .stock_authority(e.input().clone(), e.proof()) 84 .await 85 .unwrap() 86 .source_checkpoint() 87 .unwrap() 88 } 89 fn retained(outcome: StockSourceOutcome) -> StockSourceReceipt { 90 match outcome { 91 StockSourceOutcome::Committed(receipt) => receipt, 92 StockSourceOutcome::Unknown { .. } => panic!("expected a confirmed source transaction"), 93 } 94 } 95 96 #[tokio::test] 97 async fn authenticated_original_profiles_replay_and_reopen_without_changing_inventory() { 98 for row in vectors() { 99 let f = Fixture::new(); 100 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 101 let before = store 102 .stock_authority(e.input().clone(), e.proof()) 103 .await 104 .unwrap(); 105 let min = before.source_checkpoint().unwrap(); 106 let original = capture(&e, &row).await; 107 let expected = match row.name.as_str() { 108 "future_profile" | "future_version" | "other_rumor_kind" => { 109 StockSourceProfile::Unsupported 110 } 111 "record_missing_field" => StockSourceProfile::Rejected, 112 _ => StockSourceProfile::Known, 113 }; 114 assert_eq!(original.profile(), expected); 115 let receipt = retained( 116 store 117 .retain_stock_source(binding.clone(), min, &original, e.proof()) 118 .await 119 .unwrap(), 120 ); 121 assert_eq!(receipt.transaction_id(), original.transaction_id()); 122 assert_eq!(receipt.envelope_id(), original.envelope_id()); 123 assert_eq!(receipt.record_id(), original.record_id()); 124 assert_eq!(receipt.checkpoint().revision().get(), 1); 125 let replay = capture(&e, &row).await; 126 assert_ne!(replay.transaction_id(), original.transaction_id()); 127 assert_eq!( 128 retained( 129 store 130 .retain_stock_source(binding.clone(), receipt.checkpoint(), &replay, e.proof()) 131 .await 132 .unwrap() 133 ), 134 receipt 135 ); 136 let after = store 137 .stock_authority(e.input().clone(), e.proof()) 138 .await 139 .unwrap(); 140 assert_eq!(before.inventory_checkpoint(), after.inventory_checkpoint()); 141 store.close().await.unwrap(); 142 let store = NativeWorkspace::open_seller_stock( 143 &f.path, 144 e.input().clone(), 145 f.crypto(), 146 f.clock.clone(), 147 ) 148 .await 149 .unwrap(); 150 let value = store 151 .stock_source( 152 binding, 153 receipt.checkpoint(), 154 original.envelope_id(), 155 e.proof(), 156 ) 157 .await 158 .unwrap() 159 .unwrap(); 160 assert_eq!(value.receipt(), &receipt); 161 assert_eq!(value.protected_outer(), row.raw_wrap.as_bytes()); 162 assert_eq!(value.protected_seal(), row.raw_seal.as_bytes()); 163 assert_eq!(value.protected_rumor(), row.raw_rumor.as_bytes()); 164 assert_eq!( 165 value.protected_canonical_record().is_some(), 166 expected == StockSourceProfile::Known 167 ); 168 assert_eq!(format!("{value:?}"), "StockSourceSnapshot(<redacted>)"); 169 let mut conn = database(&f).await; 170 let protected: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_source_evidence") 171 .fetch_one(&mut conn) 172 .await 173 .unwrap(); 174 assert!(!String::from_utf8_lossy(&protected).contains("source-owner")); 175 let max: i64 = sqlx::query_scalar("SELECT max(length(protected)) FROM stock_source_parts") 176 .fetch_one(&mut conn) 177 .await 178 .unwrap(); 179 assert!(max <= 262144); 180 conn.close().await.unwrap(); 181 store.close().await.unwrap(); 182 } 183 } 184 185 #[tokio::test] 186 async fn every_source_write_window_rolls_back_canonical_parts_header_and_progress() { 187 for trigger in [ 188 "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_records BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", 189 "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_evidence BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", 190 "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_parts WHEN NEW.role=0 AND NEW.part=0 BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", 191 "CREATE TRIGGER source_fault BEFORE INSERT ON stock_source_parts WHEN NEW.role=2 BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", 192 "CREATE TRIGGER source_fault BEFORE UPDATE ON stock_authority BEGIN SELECT RAISE(ABORT,'isolated source fault'); END", 193 ] { 194 let row = source_vector("request/peer"); 195 let f = Fixture::new(); 196 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 197 let min = source_minimum(&store, &e).await; 198 let original = capture(&e, &row).await; 199 let mut conn = database(&f).await; 200 sqlx::raw_sql(trigger).execute(&mut conn).await.unwrap(); 201 assert_eq!( 202 store 203 .retain_stock_source(binding.clone(), min, &original, e.proof()) 204 .await, 205 Err(OperationError::StorageFailure) 206 ); 207 assert_eq!(source_minimum(&store, &e).await, min); 208 for (table, statement) in [ 209 ("records", "SELECT count(*) FROM stock_source_records"), 210 ("evidence", "SELECT count(*) FROM stock_source_evidence"), 211 ("parts", "SELECT count(*) FROM stock_source_parts"), 212 ] { 213 let count: i64 = sqlx::query_scalar(statement) 214 .fetch_one(&mut conn) 215 .await 216 .unwrap(); 217 assert_eq!(count, 0, "{table}"); 218 } 219 sqlx::raw_sql("DROP TRIGGER source_fault") 220 .execute(&mut conn) 221 .await 222 .unwrap(); 223 assert!( 224 store 225 .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) 226 .await 227 .unwrap() 228 .is_none() 229 ); 230 let receipt = retained( 231 store 232 .retain_stock_source(binding, min, &original, e.proof()) 233 .await 234 .unwrap(), 235 ); 236 assert_eq!(receipt.transaction_id(), original.transaction_id()); 237 conn.close().await.unwrap(); 238 store.close().await.unwrap(); 239 } 240 } 241 242 #[tokio::test] 243 async fn failed_source_commit_is_unknown_fences_access_and_recovers_original_anchor() { 244 let row = source_vector("request/peer"); 245 let f = Fixture::new(); 246 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 247 let min = source_minimum(&store, &e).await; 248 let original = capture(&e, &row).await; 249 let mut conn = database(&f).await; 250 sqlx::raw_sql("CREATE TABLE source_commit_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER source_commit_fault_trigger AFTER INSERT ON stock_source_evidence BEGIN INSERT INTO source_commit_fault VALUES(2); END").execute(&mut conn).await.unwrap(); 251 assert_eq!( 252 store 253 .retain_stock_source(binding.clone(), min, &original, e.proof()) 254 .await 255 .unwrap(), 256 StockSourceOutcome::Unknown { 257 transaction: original.transaction_id(), 258 envelope: original.envelope_id() 259 } 260 ); 261 assert!(matches!( 262 store 263 .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) 264 .await, 265 Err(OperationError::RecoveryRequired) 266 )); 267 store.close().await.unwrap(); 268 sqlx::raw_sql("DROP TRIGGER source_commit_fault_trigger; DROP TABLE source_commit_fault") 269 .execute(&mut conn) 270 .await 271 .unwrap(); 272 conn.close().await.unwrap(); 273 let store = 274 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 275 .await 276 .unwrap(); 277 assert!( 278 store 279 .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) 280 .await 281 .unwrap() 282 .is_none() 283 ); 284 let receipt = retained( 285 store 286 .retain_stock_source(binding, min, &original, e.proof()) 287 .await 288 .unwrap(), 289 ); 290 assert_eq!(receipt.transaction_id(), original.transaction_id()); 291 store.close().await.unwrap(); 292 } 293 294 #[tokio::test] 295 async fn current_proof_time_and_administration_gate_source_reads_and_original_replay() { 296 use radroots_storage::workspace::seller_stock::StockGrantScope; 297 let row = source_vector("request/peer"); 298 let f = Fixture::new(); 299 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 300 let min = source_minimum(&store, &e).await; 301 let original = capture(&e, &row).await; 302 let receipt = retained( 303 store 304 .retain_stock_source(binding.clone(), min, &original, e.proof()) 305 .await 306 .unwrap(), 307 ); 308 let wrong = AttachmentProof::from_protected_input(&[0xb7; 32]).unwrap(); 309 assert!(matches!( 310 store 311 .stock_source(binding.clone(), min, original.envelope_id(), &wrong) 312 .await, 313 Err(OperationError::Workspace(WorkspaceError::Unauthorized)) 314 )); 315 for time in [0, 99, 200] { 316 f.clock.0.store(time, Ordering::SeqCst); 317 assert!( 318 store 319 .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) 320 .await 321 .is_err() 322 ); 323 assert!( 324 store 325 .retain_stock_source(binding.clone(), min, &original, e.proof()) 326 .await 327 .is_err() 328 ); 329 } 330 f.clock.0.store(100, Ordering::SeqCst); 331 let child = StockGrantEnrollment::prepare( 332 &SellerAuthoritySelection::from_attachment(e.input()), 333 "physical-only".into(), 334 UnixSeconds::new(200).unwrap(), 335 StockGrantScope::full_inventory(), 336 ) 337 .unwrap(); 338 let inventory = store 339 .stock_authority(e.input().clone(), e.proof()) 340 .await 341 .unwrap() 342 .inventory_checkpoint() 343 .unwrap(); 344 let authorization = match store 345 .enroll_stock_grant(binding.clone(), inventory, e.proof(), &child) 346 .await 347 .unwrap() 348 { 349 StockGrantOutcome::Committed(receipt) => receipt.authorization(), 350 _ => panic!("grant must confirm"), 351 }; 352 let physical = store 353 .authenticate(child.input().clone(), child.proof()) 354 .await 355 .unwrap(); 356 let current_min = receipt.checkpoint().with_authorization(authorization); 357 assert!(matches!( 358 store 359 .stock_source( 360 physical.clone(), 361 current_min, 362 original.envelope_id(), 363 child.proof() 364 ) 365 .await, 366 Err(OperationError::Unauthorized) 367 )); 368 assert!(matches!( 369 store 370 .retain_stock_source(physical, current_min, &original, child.proof()) 371 .await, 372 Err(OperationError::Unauthorized) 373 )); 374 assert!(matches!( 375 store 376 .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) 377 .await, 378 Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) 379 )); 380 assert_eq!( 381 retained( 382 store 383 .retain_stock_source(binding, current_min, &original, e.proof()) 384 .await 385 .unwrap() 386 ), 387 receipt 388 ); 389 store.close().await.unwrap(); 390 } 391 392 #[tokio::test] 393 async fn source_transaction_rechecks_clock_and_expiry_after_protection_io() { 394 for next in [0, 99, 200] { 395 let row = source_vector("request/peer"); 396 let f = Fixture::new(); 397 let clock = Arc::new(AdmissionClock { 398 armed: std::sync::atomic::AtomicBool::new(false), 399 calls: AtomicU64::new(0), 400 next, 401 }); 402 let (store, e, binding) = create_source(&f, &row, clock.clone()).await; 403 let min = source_minimum(&store, &e).await; 404 let original = capture(&e, &row).await; 405 clock.armed.store(true, Ordering::SeqCst); 406 let result = store 407 .retain_stock_source(binding.clone(), min, &original, e.proof()) 408 .await; 409 if next == 200 { 410 assert_eq!( 411 result, 412 Err(OperationError::Workspace(WorkspaceError::GrantExpired)) 413 ); 414 } else { 415 assert_eq!( 416 result, 417 Err(OperationError::Workspace(WorkspaceError::Unavailable)) 418 ); 419 } 420 clock.armed.store(false, Ordering::SeqCst); 421 assert_eq!(source_minimum(&store, &e).await, min); 422 assert!( 423 store 424 .stock_source(binding, min, original.envelope_id(), e.proof()) 425 .await 426 .unwrap() 427 .is_none() 428 ); 429 store.close().await.unwrap(); 430 } 431 } 432 433 #[tokio::test] 434 async fn admitted_source_retention_survives_observer_loss_and_close_drains_original_identity() { 435 let row = source_vector("request/peer"); 436 let f = Fixture::new(); 437 let clock = Arc::new(PausedClock { 438 state: std::sync::Mutex::new((false, false, false)), 439 changed: std::sync::Condvar::new(), 440 }); 441 let (store, e, binding) = create_source(&f, &row, clock.clone()).await; 442 let min = source_minimum(&store, &e).await; 443 let original = capture(&e, &row).await; 444 clock.arm(); 445 let mut future = 446 Box::pin(store.retain_stock_source(binding.clone(), min, &original, e.proof())); 447 assert!(futures::poll!(future.as_mut()).is_pending()); 448 clock.entered(); 449 drop(future); 450 let mut closing = Box::pin(store.close()); 451 assert!(futures::poll!(closing.as_mut()).is_pending()); 452 drop(closing); 453 assert!(matches!( 454 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 455 .await, 456 Err(WorkspaceError::WriterActive) 457 )); 458 clock.release(); 459 store.close().await.unwrap(); 460 let store = 461 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 462 .await 463 .unwrap(); 464 let snapshot = store 465 .stock_source(binding.clone(), min, original.envelope_id(), e.proof()) 466 .await 467 .unwrap() 468 .unwrap(); 469 assert_eq!( 470 snapshot.receipt().transaction_id(), 471 original.transaction_id() 472 ); 473 assert_eq!( 474 &retained( 475 store 476 .retain_stock_source(binding, min, &original, e.proof()) 477 .await 478 .unwrap() 479 ), 480 snapshot.receipt() 481 ); 482 store.close().await.unwrap(); 483 } 484 485 #[tokio::test] 486 async fn missing_or_substituted_original_source_parts_and_canonical_records_are_never_repaired() { 487 for statement in [ 488 "UPDATE stock_source_parts SET protected=randomblob(length(protected)) WHERE role=0 AND part=0", 489 "UPDATE stock_source_records SET protected=randomblob(length(protected))", 490 "UPDATE stock_source_evidence SET transaction_id=zeroblob(32)", 491 "DELETE FROM stock_source_parts WHERE role=2", 492 ] { 493 let row = source_vector("request/peer"); 494 let f = Fixture::new(); 495 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 496 let min = source_minimum(&store, &e).await; 497 let original = capture(&e, &row).await; 498 let receipt = retained( 499 store 500 .retain_stock_source(binding.clone(), min, &original, e.proof()) 501 .await 502 .unwrap(), 503 ); 504 let mut conn = database(&f).await; 505 sqlx::raw_sql(statement).execute(&mut conn).await.unwrap(); 506 assert!( 507 store 508 .stock_source( 509 binding.clone(), 510 receipt.checkpoint(), 511 original.envelope_id(), 512 e.proof() 513 ) 514 .await 515 .is_err() 516 ); 517 assert!( 518 store 519 .retain_stock_source(binding, receipt.checkpoint(), &original, e.proof()) 520 .await 521 .is_err() 522 ); 523 conn.close().await.unwrap(); 524 store.close().await.unwrap(); 525 } 526 } 527 528 #[tokio::test] 529 async fn retained_source_checkpoint_refuses_full_database_restore_and_foreign_or_forked_minima() { 530 let row = source_vector("request/peer"); 531 let f = Fixture::new(); 532 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 533 let min = source_minimum(&store, &e).await; 534 store.close().await.unwrap(); 535 let path = f.path.join("stock_execution_v1.sqlite"); 536 let original_db = std::fs::read(&path).unwrap(); 537 let store = 538 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 539 .await 540 .unwrap(); 541 let original = capture(&e, &row).await; 542 let receipt = retained( 543 store 544 .retain_stock_source(binding.clone(), min, &original, e.proof()) 545 .await 546 .unwrap(), 547 ); 548 let fork = StockSourceCheckpointRef::from_host_metadata( 549 min.authority(), 550 receipt.checkpoint().revision(), 551 Some(radroots_domain::CheckpointDigest::from_bytes([0xc9; 32])), 552 ) 553 .unwrap() 554 .with_optional_authorization(min.authorization()); 555 assert!(matches!( 556 store 557 .stock_source(binding.clone(), fork, original.envelope_id(), e.proof()) 558 .await, 559 Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) 560 )); 561 let foreign = StockSourceCheckpointRef::from_host_metadata( 562 AuthorityRef::new( 563 ExecutorId::from_bytes([0xc7; 32]), 564 min.authority().generation(), 565 ), 566 min.revision(), 567 None, 568 ) 569 .unwrap() 570 .with_optional_authorization(min.authorization()); 571 assert!(matches!( 572 store 573 .stock_source(binding.clone(), foreign, original.envelope_id(), e.proof()) 574 .await, 575 Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) 576 )); 577 store.close().await.unwrap(); 578 std::fs::write(&path, original_db).unwrap(); 579 let store = 580 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 581 .await 582 .unwrap(); 583 assert!(matches!( 584 store 585 .stock_source( 586 binding.clone(), 587 receipt.checkpoint(), 588 original.envelope_id(), 589 e.proof() 590 ) 591 .await, 592 Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) 593 )); 594 assert!(matches!( 595 store 596 .retain_stock_source(binding, receipt.checkpoint(), &original, e.proof()) 597 .await, 598 Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) 599 )); 600 store.close().await.unwrap(); 601 } 602 603 #[tokio::test] 604 async fn separate_authenticated_envelopes_keep_both_originals_and_one_logical_record() { 605 use nostr::{EventBuilder, JsonUtil, Keys, UnsignedEvent}; 606 let row = source_vector("quote/peer"); 607 let f = Fixture::new(); 608 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 609 let min = source_minimum(&store, &e).await; 610 let original = capture(&e, &row).await; 611 let sender = Keys::parse(&format!("{:064x}", 1)).unwrap(); 612 let recipient = nostr::PublicKey::from_hex(&signer(&row).public_key().to_hex()).unwrap(); 613 let rumor = UnsignedEvent::from_json(&row.raw_rumor).unwrap(); 614 let event = EventBuilder::gift_wrap(&sender, &recipient, rumor, []) 615 .await 616 .unwrap(); 617 let mut second = row.clone(); 618 second.raw_wrap = event.as_json(); 619 let other = capture(&e, &second).await; 620 assert_eq!(other.record_id(), original.record_id()); 621 assert_ne!(other.envelope_id(), original.envelope_id()); 622 let first = retained( 623 store 624 .retain_stock_source(binding.clone(), min, &original, e.proof()) 625 .await 626 .unwrap(), 627 ); 628 let next = retained( 629 store 630 .retain_stock_source(binding.clone(), first.checkpoint(), &other, e.proof()) 631 .await 632 .unwrap(), 633 ); 634 assert_eq!(next.checkpoint().revision().get(), 2); 635 assert_ne!(first.checkpoint().head(), next.checkpoint().head()); 636 let mut conn = database(&f).await; 637 let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_source_records") 638 .fetch_one(&mut conn) 639 .await 640 .unwrap(); 641 assert_eq!(count, 1); 642 conn.close().await.unwrap(); 643 store.close().await.unwrap(); 644 let store = 645 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 646 .await 647 .unwrap(); 648 for (capture, raw) in [ 649 (&original, row.raw_wrap.as_bytes()), 650 (&other, second.raw_wrap.as_bytes()), 651 ] { 652 let value = store 653 .stock_source( 654 binding.clone(), 655 first.checkpoint(), 656 capture.envelope_id(), 657 e.proof(), 658 ) 659 .await 660 .unwrap() 661 .unwrap(); 662 assert_eq!(value.protected_outer(), raw); 663 } 664 assert_eq!( 665 retained( 666 store 667 .retain_stock_source(binding, next.checkpoint(), &original, e.proof()) 668 .await 669 .unwrap() 670 ), 671 first 672 ); 673 store.close().await.unwrap(); 674 } 675 676 #[tokio::test] 677 async fn same_envelope_identity_with_different_original_bytes_is_a_conflict() { 678 let row = source_vector("request/peer"); 679 let f = Fixture::new(); 680 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 681 let min = source_minimum(&store, &e).await; 682 let original = capture(&e, &row).await; 683 let receipt = retained( 684 store 685 .retain_stock_source(binding.clone(), min, &original, e.proof()) 686 .await 687 .unwrap(), 688 ); 689 let mut alias = row.clone(); 690 alias.raw_wrap = serde_json::to_string_pretty( 691 &serde_json::from_str::<serde_json::Value>(&row.raw_wrap).unwrap(), 692 ) 693 .unwrap(); 694 let alias = capture(&e, &alias).await; 695 assert_eq!(alias.envelope_id(), original.envelope_id()); 696 assert_eq!( 697 store 698 .retain_stock_source(binding.clone(), receipt.checkpoint(), &alias, e.proof()) 699 .await, 700 Err(OperationError::IdempotencyConflict) 701 ); 702 assert_eq!(source_minimum(&store, &e).await, receipt.checkpoint()); 703 let value = store 704 .stock_source( 705 binding, 706 receipt.checkpoint(), 707 original.envelope_id(), 708 e.proof(), 709 ) 710 .await 711 .unwrap() 712 .unwrap(); 713 assert_eq!(value.protected_outer(), row.raw_wrap.as_bytes()); 714 store.close().await.unwrap(); 715 } 716 717 #[tokio::test] 718 async fn inventory_progress_preserves_source_checkpoint_and_original_evidence() { 719 let row = source_vector("request/peer"); 720 let f = Fixture::new(); 721 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 722 let min = source_minimum(&store, &e).await; 723 let original = capture(&e, &row).await; 724 let receipt = retained( 725 store 726 .retain_stock_source(binding.clone(), min, &original, e.proof()) 727 .await 728 .unwrap(), 729 ); 730 let inventory = committed( 731 store 732 .execute_inventory(request(&binding, 1, 2, "Carrots"), proof(e.proof())) 733 .await 734 .unwrap(), 735 ); 736 assert_eq!(inventory.checkpoint().revision().get(), 1); 737 assert_eq!(source_minimum(&store, &e).await, receipt.checkpoint()); 738 store.close().await.unwrap(); 739 let store = 740 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) 741 .await 742 .unwrap(); 743 assert_eq!( 744 store 745 .stock_source( 746 binding, 747 receipt.checkpoint(), 748 original.envelope_id(), 749 e.proof() 750 ) 751 .await 752 .unwrap() 753 .unwrap() 754 .receipt(), 755 &receipt 756 ); 757 store.close().await.unwrap(); 758 }