lib

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

receipt_public_delivery.rs (27598B)


      1 //! Actual native public D over the existing journal and qualified Nostr sink.
      2 use super::*;
      3 use futures::{SinkExt, StreamExt};
      4 use nostr::JsonUtil;
      5 use radroots_nostr::{
      6     key::parse_secret_key,
      7     signing::{LocalSigner, OsNonceSource},
      8 };
      9 use radroots_protocol::{intent::SigningReplay, listing::PublicSigningPlan};
     10 use radroots_signing::{
     11     issuance::{OutcomeKind, SigningIntent},
     12     provider::{ParticipantProvider, ProviderCall},
     13     request::CancellationSignal,
     14 };
     15 use radroots_storage::command::{
     16     ArtifactEvidence, ClaimAttemptOutcome, ClaimAttemptRequest, DeliveryAttempt,
     17     DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryIntent, DeliveryObservation,
     18     DeliveryObservationKind, DeliveryObservationOutcome, EvidenceCaptureOutcome,
     19     InstallationOutcome, InstallationRequest, PlanBindingOutcome, PublicPublicationWork,
     20     PublicationArtifact, SigningTarget,
     21 };
     22 use radroots_transport::{
     23     EventSink, TargetSet,
     24     policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy},
     25 };
     26 use radroots_transport_nostr::{
     27     Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy,
     28 };
     29 use std::{
     30     num::NonZeroU64,
     31     time::{SystemTime, UNIX_EPOCH},
     32 };
     33 use tokio::net::TcpListener;
     34 use tokio_tungstenite::{accept_async, tungstenite::Message};
     35 fn now_ms() -> u64 {
     36     SystemTime::now()
     37         .duration_since(UNIX_EPOCH)
     38         .unwrap()
     39         .as_millis()
     40         .try_into()
     41         .unwrap()
     42 }
     43 fn signer_now() -> Result<u64, radroots_signing::Error> {
     44     Ok(now_ms())
     45 }
     46 struct Ready {
     47     fixture: Fixture,
     48     store: Arc<NativeWorkspace>,
     49     input: AttachmentInput,
     50     proof: AttachmentProof,
     51     binding: WorkspaceBinding,
     52     work: PublicPublicationWork,
     53     raw: String,
     54     config: Config,
     55 }
     56 impl Ready {
     57     async fn new(urls: &[String], id: u8) -> Self {
     58         let fixture = Fixture::new();
     59         let time = now_ms() / 1000;
     60         fixture.clock.now.store(time, Ordering::SeqCst);
     61         let (store, input, proof) = NativeWorkspace::initialize_local_outbox(
     62             &fixture.path,
     63             LocalOutboxConfig::seller(
     64                 key(),
     65                 key(),
     66                 "public-delivery",
     67                 UnixSeconds::new(time + 600).unwrap(),
     68             )
     69             .unwrap(),
     70             fixture.crypto(),
     71             fixture.clock.clone(),
     72         )
     73         .await
     74         .unwrap();
     75         let binding = store.authenticate(input.clone(), &proof).await.unwrap();
     76         let store = Arc::new(store);
     77         let context = CommandContextData::new(
     78             OperationId::from_bytes([id; 32]),
     79             binding.actor(),
     80             input.workspace_id(),
     81             input.authority(),
     82             input.route_digest(),
     83             None,
     84             None,
     85             UnixSeconds::new(time + 120).unwrap(),
     86             None,
     87         )
     88         .unwrap();
     89         let wire = json!({"type":"listing.publish","context":context,"input":{"id":format!("{id:02x}").repeat(16),"title":"Native public delivery","summary":"Quote required","description_markdown":"Public terms","published_at":time.to_string(),"profile":{"profile":"radroots.listing","version":1,"state":"active","product":{"name":"Carrots","description":"x".repeat(4096),"producer":null,"origin_summary":null},"default_option":"02".repeat(32),"options":[{"id":"02".repeat(32),"label":"Bunch","unit":{"type":"package","label":"bunch","contents":{"type":"unspecified"}},"increment":"1","minimum":"1","price":{"type":"quote_required"},"supply":{"type":"available","amount":"10"},"lead_seconds":"0"}],"fulfillment":{"modes":["pickup"],"area":"Example","lead_seconds":"0"},"authority":null,"media":[]}}});
     90         let prepared = committed(
     91             store
     92                 .admit_command_and_hold(
     93                     AdmissionRequest::from_protected_wire(
     94                         binding.clone(),
     95                         &serde_json::to_vec(&wire).unwrap(),
     96                     )
     97                     .unwrap(),
     98                     copy(&proof),
     99                 )
    100                 .await
    101                 .unwrap(),
    102         );
    103         let plan = PublicSigningPlan::capture(
    104             prepared.request().command().listing().unwrap(),
    105             UnixSeconds::new(time).unwrap(),
    106             urls,
    107             SigningReplay::NonReplayable,
    108         )
    109         .unwrap();
    110         let digest = *plan.digest();
    111         assert!(
    112             plan.event()
    113                 .fields()
    114                 .tags
    115                 .iter()
    116                 .any(|tag| tag.iter().any(|field| field.len() > 4096))
    117         );
    118         let PlanBindingOutcome::Committed(_) = store
    119             .bind_signing_intents(binding.clone(), plan.into(), copy(&proof))
    120             .await
    121             .unwrap()
    122         else {
    123             panic!("actual T1 commit")
    124         };
    125         let ClaimAttemptOutcome::Claimed(attempt) = store
    126             .claim_attempt(
    127                 ClaimAttemptRequest::for_artifact(
    128                     binding.clone(),
    129                     prepared.identity().operation_id(),
    130                     prepared.identity().command_digest(),
    131                     digest,
    132                     SigningTarget::PublicEvent,
    133                 ),
    134                 copy(&proof),
    135             )
    136             .await
    137             .unwrap()
    138         else {
    139             panic!("actual first claim")
    140         };
    141         let signer = LocalSigner::with_clock(
    142             parse_secret_key("0000000000000000000000000000000000000000000000000000000000000001")
    143                 .unwrap(),
    144             signer_now,
    145         )
    146         .unwrap()
    147         .with_nonce_source(Arc::new(OsNonceSource));
    148         let intent = SigningIntent::from_plan(
    149             attempt.bound_plan().plan(),
    150             SigningTarget::PublicEvent,
    151             ProviderCall::new(key(), attempt.deadline_unix_ms(), CancellationSignal::new()),
    152         )
    153         .unwrap();
    154         let (_, outcome) = signer.sign_exact(intent).await.into_parts();
    155         let OutcomeKind::Obtained(artifact) = outcome else {
    156             panic!("actual public signature")
    157         };
    158         let evidence = artifact.with_json(|raw| {
    159             nostr::Event::from_json(raw).unwrap().verify().unwrap();
    160             ArtifactEvidence::verify(&attempt, raw, artifact.observed_at_unix_ms()).unwrap()
    161         });
    162         let raw = evidence.raw_json().to_owned();
    163         assert!(matches!(
    164             store
    165                 .capture_evidence(input.clone(), &proof, &evidence)
    166                 .await
    167                 .unwrap(),
    168             EvidenceCaptureOutcome::Committed(_)
    169         ));
    170         assert!(matches!(
    171             store
    172                 .install_transition_and_outbox(
    173                     InstallationRequest::new(
    174                         binding.clone(),
    175                         prepared.identity().operation_id(),
    176                         prepared.identity().command_digest(),
    177                         digest
    178                     ),
    179                     copy(&proof)
    180                 )
    181                 .await
    182                 .unwrap(),
    183             InstallationOutcome::ListingCommitted(_)
    184         ));
    185         let snapshot = store
    186             .operation_snapshot(
    187                 binding.clone(),
    188                 prepared.identity().operation_id(),
    189                 None,
    190                 copy(&proof),
    191             )
    192             .await
    193             .unwrap()
    194             .unwrap();
    195         let work = snapshot.public_publications()[0];
    196         let config = Config::from_profile(
    197             RelayProfile::explicit(
    198                 RelayProfileKind::Simulator,
    199                 urls.iter().map(|url| {
    200                     RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()
    201                 }),
    202             )
    203             .unwrap(),
    204         )
    205         .with_timeouts(1000, 1000, 500)
    206         .unwrap();
    207         Self {
    208             fixture,
    209             store,
    210             input,
    211             proof,
    212             binding,
    213             work,
    214             raw,
    215             config,
    216         }
    217     }
    218     fn targets(&self) -> TargetSet {
    219         TargetSet::new(
    220             self.config
    221                 .relays()
    222                 .iter()
    223                 .map(|v| v.to_target().unwrap())
    224                 .collect(),
    225         )
    226         .unwrap()
    227     }
    228     fn request(&self, id: u8) -> DeliveryAttemptRequest {
    229         let now = self.fixture.clock.now().unwrap().get() * 1000;
    230         DeliveryAttemptRequest::new(
    231             self.binding.clone(),
    232             self.work,
    233             DeliveryIntent::public(
    234                 &format!("{id:02x}").repeat(32),
    235                 self.work.evidence().event_id(),
    236                 &self.targets(),
    237                 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    238                 NonZeroU64::new(now + 60_000).unwrap(),
    239             )
    240             .unwrap(),
    241         )
    242         .unwrap()
    243     }
    244     async fn retain(&self, id: u8) -> DeliveryAttempt {
    245         match self
    246             .store
    247             .prepare_delivery_attempt(self.request(id), copy(&self.proof), None)
    248             .await
    249             .unwrap()
    250         {
    251             DeliveryAttemptOutcome::Claimed(v) => *v,
    252             _ => panic!("actual fresh public D claim"),
    253         }
    254     }
    255     async fn snapshot(
    256         &self,
    257         store: &NativeWorkspace,
    258     ) -> radroots_storage::command::OperationSnapshot {
    259         store
    260             .operation_snapshot(
    261                 self.binding.clone(),
    262                 self.work.evidence().operation_id(),
    263                 Some(self.work.evidence().command_digest()),
    264                 copy(&self.proof),
    265             )
    266             .await
    267             .unwrap()
    268             .unwrap()
    269     }
    270     async fn query(
    271         &self,
    272         store: &NativeWorkspace,
    273         id: &radroots_transport::sink::DeliveryRequestId,
    274     ) -> Option<DeliveryAttempt> {
    275         store
    276             .delivery_attempt(
    277                 self.binding.clone(),
    278                 self.work.evidence().operation_id(),
    279                 self.work.evidence().command_digest(),
    280                 SigningTarget::PublicEvent,
    281                 id.clone(),
    282                 copy(&self.proof),
    283             )
    284             .await
    285             .unwrap()
    286     }
    287 }
    288 #[tokio::test]
    289 async fn public_d_retains_original_before_actual_loopback_and_reopens_independent_ack() {
    290     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    291     let ready = Ready::new(&[format!("ws://{}", listener.local_addr().unwrap())], 180).await;
    292     let attempt = ready.retain(1).await;
    293     assert_eq!(attempt.raw_json(), ready.raw);
    294     assert_eq!(attempt.work(), PublicationArtifact::Public(ready.work));
    295     assert_eq!(attempt.work().recipient(), None);
    296     assert_eq!(
    297         attempt.intent().event_id(),
    298         ready.work.evidence().event_id()
    299     );
    300     let snapshot = ready.snapshot(&ready.store).await;
    301     let checkpoint = snapshot.checkpoint_digest();
    302     assert!(snapshot.installed_message().is_none());
    303     assert!(snapshot.publications().is_empty());
    304     assert_eq!(snapshot.public_publications(), &[ready.work]);
    305     assert_eq!(snapshot.delivery_attempts().len(), 1);
    306     assert!(!snapshot.publication_accepted(ready.work).unwrap());
    307     assert!(matches!(
    308         ready
    309             .store
    310             .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None)
    311             .await
    312             .unwrap(),
    313         DeliveryAttemptOutcome::Retained(_)
    314     ));
    315     let expected = format!("[\"EVENT\",{}]", ready.raw);
    316     let server = tokio::spawn(async move {
    317         let (tcp, _) = listener.accept().await.unwrap();
    318         let mut socket = accept_async(tcp).await.unwrap();
    319         let raw = tokio::time::timeout(Duration::from_secs(5), async {
    320             loop {
    321                 if let Message::Text(raw) = socket.next().await.unwrap().unwrap() {
    322                     break raw;
    323                 }
    324             }
    325         })
    326         .await
    327         .unwrap();
    328         assert_eq!(raw.as_str(), expected);
    329         let frame: serde_json::Value = serde_json::from_str(&raw).unwrap();
    330         let event = nostr::Event::from_json(frame[1].to_string()).unwrap();
    331         event.verify().unwrap();
    332         assert_eq!(event.kind.as_u16(), 30402);
    333         socket
    334             .send(Message::Text(
    335                 json!(["OK", "ff".repeat(32), true, ""]).to_string().into(),
    336             ))
    337             .await
    338             .unwrap();
    339         socket
    340             .send(Message::Text(
    341                 json!(["OK", frame[1]["id"], true, ""]).to_string().into(),
    342             ))
    343             .await
    344             .unwrap();
    345     });
    346     let transport = radroots_transport_nostr_native::create_transport(ready.config.clone());
    347     let request = attempt.transport_request().unwrap();
    348     let selected = attempt.intent().selected_target_set().unwrap();
    349     let receipt = transport
    350         .deliver_selected(request.clone(), selected)
    351         .await
    352         .unwrap();
    353     receipt.validate_for_request(&request).unwrap();
    354     assert!(receipt.is_satisfied(&request).unwrap());
    355     server.await.unwrap();
    356     let observation = DeliveryObservation::from_receipt(
    357         &attempt,
    358         &receipt,
    359         request.target_set().targets()[0].fingerprint(),
    360         None,
    361     )
    362     .unwrap();
    363     assert_eq!(observation.kind(), DeliveryObservationKind::Accepted);
    364     let DeliveryObservationOutcome::Committed(first) = ready
    365         .store
    366         .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation)
    367         .await
    368         .unwrap()
    369     else {
    370         panic!("actual durable ACK")
    371     };
    372     let complete = ready.snapshot(&ready.store).await;
    373     assert_ne!(complete.checkpoint_digest(), checkpoint);
    374     assert!(complete.publication_accepted(ready.work).unwrap());
    375     assert_eq!(
    376         complete.listing_installation(),
    377         snapshot.listing_installation()
    378     );
    379     transport.shutdown().await;
    380     ready.store.close().await.unwrap();
    381     let reopened = ready.fixture.reopen(ready.input.clone()).await;
    382     let retained = ready
    383         .query(&reopened, attempt.intent().request_id())
    384         .await
    385         .unwrap();
    386     assert_eq!(retained.raw_json(), ready.raw);
    387     assert_eq!(retained.transaction_id(), attempt.transaction_id());
    388     let observations = reopened
    389         .delivery_observations(
    390             ready.binding.clone(),
    391             ready.work.evidence().operation_id(),
    392             ready.work.evidence().command_digest(),
    393             SigningTarget::PublicEvent,
    394             attempt.intent().request_id().clone(),
    395             copy(&ready.proof),
    396         )
    397         .await
    398         .unwrap();
    399     assert_eq!(observations, vec![first]);
    400     assert!(
    401         ready
    402             .snapshot(&reopened)
    403             .await
    404             .publication_accepted(ready.work)
    405             .unwrap()
    406     );
    407     reopened.close().await.unwrap();
    408 }
    409 #[tokio::test]
    410 async fn public_d_requires_original_targets_role_and_current_proof_before_any_claim() {
    411     let ready = Ready::new(&["ws://127.0.0.1:9".into()], 181).await;
    412     assert!(
    413         DeliveryAttemptRequest::new(
    414             ready.binding.clone(),
    415             ready.work,
    416             DeliveryIntent::new(
    417                 &"11".repeat(32),
    418                 ready.work.evidence().event_id(),
    419                 &ready.targets(),
    420                 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    421                 NonZeroU64::new(now_ms() + 60_000).unwrap()
    422             )
    423             .unwrap()
    424         )
    425         .is_err()
    426     );
    427     assert!(matches!(
    428         ready
    429             .store
    430             .prepare_delivery_attempt(
    431                 ready.request(1),
    432                 AttachmentProof::from_protected_input(&[0; 32]).unwrap(),
    433                 None
    434             )
    435             .await,
    436         Err(OperationError::Workspace(WorkspaceError::Unauthorized))
    437     ));
    438     let other = TargetSet::new(vec![
    439         radroots_transport::Target::nostr_relay("ws://127.0.0.1:10").unwrap(),
    440     ])
    441     .unwrap();
    442     let request = DeliveryAttemptRequest::new(
    443         ready.binding.clone(),
    444         ready.work,
    445         DeliveryIntent::public(
    446             &"11".repeat(32),
    447             ready.work.evidence().event_id(),
    448             &other,
    449             &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    450             NonZeroU64::new(now_ms() + 60_000).unwrap(),
    451         )
    452         .unwrap(),
    453     )
    454     .unwrap();
    455     assert!(matches!(
    456         ready
    457             .store
    458             .prepare_delivery_attempt(request, copy(&ready.proof), None)
    459             .await,
    460         Err(OperationError::UnverifiedApproval)
    461     ));
    462     assert!(
    463         ready
    464             .snapshot(&ready.store)
    465             .await
    466             .delivery_attempts()
    467             .is_empty()
    468     );
    469     ready.store.close().await.unwrap();
    470 }
    471 #[tokio::test]
    472 async fn public_retries_reuse_original_after_first_issue_expiry_and_spend_twelve_endpoint_slots() {
    473     let ready = Ready::new(&["ws://127.0.0.1:9".into()], 182).await;
    474     ready.fixture.clock.now.fetch_add(121, Ordering::SeqCst);
    475     for id in 1..=12 {
    476         let attempt = ready.retain(id).await;
    477         assert_eq!(attempt.raw_json(), ready.raw);
    478         assert_eq!(attempt.target_ordinals(), &[id]);
    479     }
    480     assert!(matches!(
    481         ready
    482             .store
    483             .prepare_delivery_attempt(ready.request(13), copy(&ready.proof), None)
    484             .await,
    485         Err(OperationError::DeliveryAttemptLimit)
    486     ));
    487     assert!(matches!(
    488         ready
    489             .store
    490             .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None)
    491             .await
    492             .unwrap(),
    493         DeliveryAttemptOutcome::Retained(_)
    494     ));
    495     let state = ready.snapshot(&ready.store).await;
    496     assert_eq!(state.delivery_attempts().len(), 12);
    497     assert!(state.delivery_observations().is_empty());
    498     assert!(!state.publication_accepted(ready.work).unwrap());
    499     ready.store.close().await.unwrap();
    500     let reopened = ready.fixture.reopen(ready.input.clone()).await;
    501     let state = ready.snapshot(&reopened).await;
    502     assert_eq!(state.delivery_attempts().len(), 12);
    503     reopened.close().await.unwrap();
    504 }
    505 #[tokio::test]
    506 async fn public_d_part_insert_failure_rolls_back_without_losing_installed_revision() {
    507     let ready = Ready::new(&["ws://127.0.0.1:9".into()], 183).await;
    508     let mut db = ready.fixture.database().await;
    509     sqlx::raw_sql("CREATE TRIGGER fail_public_d BEFORE INSERT ON artifact_delivery_parts BEGIN SELECT RAISE(ABORT,'isolated fixture'); END").execute(&mut db).await.unwrap();
    510     assert!(matches!(
    511         ready
    512             .store
    513             .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None)
    514             .await,
    515         Err(OperationError::StorageFailure)
    516     ));
    517     let state = ready.snapshot(&ready.store).await;
    518     assert!(state.listing_installation().is_some());
    519     assert!(state.delivery_attempts().is_empty());
    520     sqlx::query("DROP TRIGGER fail_public_d")
    521         .execute(&mut db)
    522         .await
    523         .unwrap();
    524     db.close().await.unwrap();
    525     let retained = ready.retain(1).await;
    526     assert_eq!(retained.raw_json(), ready.raw);
    527     ready.store.close().await.unwrap();
    528 }
    529 #[tokio::test]
    530 async fn lost_public_d_observer_never_turns_reopen_into_dispatch_permission() {
    531     let ready = Ready::new(&["ws://127.0.0.1:9".into()], 184).await;
    532     let (arrived, resume) = ready.fixture.clock.arm(1);
    533     let mut pending =
    534         ready
    535             .store
    536             .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None);
    537     assert!(futures::poll!(pending.as_mut()).is_pending());
    538     reached(arrived).await;
    539     drop(pending);
    540     resume.send(()).unwrap();
    541     ready.store.close().await.unwrap();
    542     let reopened = ready.fixture.reopen(ready.input.clone()).await;
    543     assert!(matches!(
    544         reopened
    545             .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None)
    546             .await
    547             .unwrap(),
    548         DeliveryAttemptOutcome::Retained(_)
    549     ));
    550     assert_eq!(ready.snapshot(&reopened).await.delivery_attempts().len(), 1);
    551     reopened.close().await.unwrap();
    552 }
    553 
    554 #[tokio::test]
    555 async fn actual_public_rejection_disconnect_and_missing_matching_ack_remain_independent() {
    556     for (mode, expected) in [
    557         (0, DeliveryObservationKind::Rejected),
    558         (1, DeliveryObservationKind::Disconnected),
    559         (2, DeliveryObservationKind::TimedOut),
    560     ] {
    561         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    562         let ready = Ready::new(
    563             &[format!("ws://{}", listener.local_addr().unwrap())],
    564             185 + mode,
    565         )
    566         .await;
    567         let deadline = NonZeroU64::new(now_ms() + 2_000).unwrap();
    568         let request = DeliveryAttemptRequest::new(
    569             ready.binding.clone(),
    570             ready.work,
    571             DeliveryIntent::public(
    572                 &format!("{mode:02x}").repeat(32),
    573                 ready.work.evidence().event_id(),
    574                 &ready.targets(),
    575                 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
    576                 deadline,
    577             )
    578             .unwrap(),
    579         )
    580         .unwrap();
    581         let DeliveryAttemptOutcome::Claimed(attempt) = ready
    582             .store
    583             .prepare_delivery_attempt(request, copy(&ready.proof), None)
    584             .await
    585             .unwrap()
    586         else {
    587             panic!("actual public D")
    588         };
    589         let (release, held) = tokio::sync::oneshot::channel::<()>();
    590         let server = tokio::spawn(async move {
    591             let (tcp, _) = listener.accept().await.unwrap();
    592             let mut socket = accept_async(tcp).await.unwrap();
    593             let raw = tokio::time::timeout(Duration::from_secs(5), async {
    594                 loop {
    595                     if let Message::Text(raw) = socket.next().await.unwrap().unwrap() {
    596                         break raw;
    597                     }
    598                 }
    599             })
    600             .await
    601             .unwrap();
    602             let event: serde_json::Value = serde_json::from_str(&raw).unwrap();
    603             match mode {
    604                 0 => socket
    605                     .send(Message::Text(
    606                         json!(["OK", event[1]["id"], false, "blocked: denied"])
    607                             .to_string()
    608                             .into(),
    609                     ))
    610                     .await
    611                     .unwrap(),
    612                 1 => {
    613                     socket.close(None).await.unwrap();
    614                 }
    615                 _ => socket
    616                     .send(Message::Text(
    617                         json!(["OK", "ff".repeat(32), true, ""]).to_string().into(),
    618                     ))
    619                     .await
    620                     .unwrap(),
    621             }
    622             let _ = held.await;
    623         });
    624         let transport = radroots_transport_nostr_native::create_transport(ready.config.clone());
    625         let request = attempt.transport_request().unwrap();
    626         let target = request.target_set().targets()[0].fingerprint();
    627         let result = transport
    628             .deliver_selected(
    629                 request.clone(),
    630                 attempt.intent().selected_target_set().unwrap(),
    631             )
    632             .await;
    633         let observation = match result {
    634             Ok(receipt) => {
    635                 assert!(!receipt.is_satisfied(&request).unwrap());
    636                 DeliveryObservation::from_receipt(&attempt, &receipt, target, None).unwrap()
    637             }
    638             Err(failure) => {
    639                 DeliveryObservation::from_failure(&attempt, &failure, target, None).unwrap()
    640             }
    641         };
    642         assert_eq!(observation.kind(), expected);
    643         // Already obtained original target evidence remains capturable while a
    644         // fresh clock/access check would refuse another operation.
    645         ready.fixture.clock.now.store(0, Ordering::SeqCst);
    646         assert!(matches!(
    647             ready
    648                 .store
    649                 .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation)
    650                 .await
    651                 .unwrap(),
    652             DeliveryObservationOutcome::Committed(_)
    653         ));
    654         ready
    655             .fixture
    656             .clock
    657             .now
    658             .store(now_ms() / 1000, Ordering::SeqCst);
    659         assert!(
    660             !ready
    661                 .snapshot(&ready.store)
    662                 .await
    663                 .publication_accepted(ready.work)
    664                 .unwrap()
    665         );
    666         let _ = release.send(());
    667         server.await.unwrap();
    668         transport.shutdown().await;
    669         ready.store.close().await.unwrap();
    670     }
    671 }
    672 #[tokio::test]
    673 async fn unknown_public_d_commit_requires_safe_reopen_and_never_reports_a_dispatch_right() {
    674     let ready = Ready::new(&["ws://127.0.0.1:9".into()], 188).await;
    675     let mut db = ready.fixture.database().await;
    676     sqlx::raw_sql("CREATE TABLE deferred_d_fault(value INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER fail_public_d_commit AFTER INSERT ON artifact_delivery_attempts BEGIN INSERT INTO deferred_d_fault VALUES(2); END").execute(&mut db).await.unwrap();
    677     let request = ready.request(1);
    678     let id = request.intent().request_id().clone();
    679     let DeliveryAttemptOutcome::Unknown { operation, attempt } = ready
    680         .store
    681         .prepare_delivery_attempt(request, copy(&ready.proof), None)
    682         .await
    683         .unwrap()
    684     else {
    685         panic!("actual failed COMMIT must be unknown")
    686     };
    687     assert_eq!(attempt, id);
    688     assert_eq!(
    689         operation.operation_id(),
    690         ready.work.evidence().operation_id()
    691     );
    692     assert!(operation.transaction_id().is_some());
    693     assert!(matches!(
    694         ready
    695             .store
    696             .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None)
    697             .await,
    698         Err(OperationError::RecoveryRequired)
    699     ));
    700     ready.store.close().await.unwrap();
    701     sqlx::raw_sql("DROP TRIGGER fail_public_d_commit; DROP TABLE deferred_d_fault")
    702         .execute(&mut db)
    703         .await
    704         .unwrap();
    705     db.close().await.unwrap();
    706     let reopened = ready.fixture.reopen(ready.input.clone()).await;
    707     assert!(ready.query(&reopened, &id).await.is_none());
    708     let state = ready.snapshot(&reopened).await;
    709     assert!(state.delivery_attempts().is_empty());
    710     assert!(state.listing_installation().is_some());
    711     assert!(!state.publication_accepted(ready.work).unwrap());
    712     reopened.close().await.unwrap();
    713 }
    714 #[tokio::test]
    715 async fn current_public_scope_and_original_policy_cannot_be_replaced_by_a_new_attempt() {
    716     let ready = Ready::new(&["ws://127.0.0.1:9".into()], 189).await;
    717     let original = ready.retain(1).await;
    718     let changed = DeliveryAttemptRequest::new(
    719         ready.binding.clone(),
    720         ready.work,
    721         DeliveryIntent::public(
    722             &"02".repeat(32),
    723             ready.work.evidence().event_id(),
    724             &ready.targets(),
    725             &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::any()),
    726             NonZeroU64::new(now_ms() + 60_000).unwrap(),
    727         )
    728         .unwrap(),
    729     )
    730     .unwrap();
    731     assert!(matches!(
    732         ready
    733             .store
    734             .prepare_delivery_attempt(changed, copy(&ready.proof), None)
    735             .await,
    736         Err(OperationError::IdempotencyConflict)
    737     ));
    738     ready
    739         .store
    740         .revoke(ready.input.clone(), &ready.proof)
    741         .await
    742         .unwrap();
    743     assert!(matches!(
    744         ready
    745             .store
    746             .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None)
    747             .await,
    748         Err(OperationError::Workspace(WorkspaceError::GrantRevoked))
    749     ));
    750     assert_eq!(original.raw_json(), ready.raw);
    751     ready.store.close().await.unwrap();
    752 }