lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }