lib

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

receipt_delivery_admission.rs (16523B)


      1 use super::*;
      2 use radroots_domain::{EnvelopeEventId, TransactionId};
      3 use radroots_transport::{
      4     outcome::DeliveryOutcome,
      5     sink::{DeliveryRequestId, DeliveryTargetReceipt},
      6 };
      7 
      8 #[tokio::test]
      9 async fn native_delivery_matches_original_signed_root_slash_route_to_canonical_target() {
     10     let ready = Ready::new(&[String::from("ws://127.0.0.1:9/")], 250).await;
     11     let retained = ready.retain(1).await;
     12     assert_eq!(
     13         retained.intent().targets().targets()[0].uri().as_str(),
     14         "ws://127.0.0.1:9"
     15     );
     16     assert_eq!(
     17         ready
     18             .query(&ready.store, retained.intent().request_id())
     19             .await
     20             .raw_json(),
     21         retained.raw_json()
     22     );
     23     ready.store.close().await.unwrap();
     24 }
     25 
     26 #[tokio::test]
     27 async fn self_copy_delivery_refuses_the_original_peer_as_temporary_author() {
     28     use radroots_storage::command::ClaimAttemptRequest;
     29     let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 251).await;
     30     let e = ready.work.evidence();
     31     let original = ready
     32         .store
     33         .operation_snapshot(
     34             ready.binding.clone(),
     35             e.operation_id(),
     36             None,
     37             copy(&ready.proof),
     38         )
     39         .await
     40         .unwrap()
     41         .unwrap();
     42     let plan = *original.bound_plan().unwrap().plan().digest();
     43     let installation = original.installation().unwrap().transaction_id();
     44     let claim = issuance::claim(
     45         ready
     46             .store
     47             .claim_attempt(
     48                 ClaimAttemptRequest::new(
     49                     ready.binding.clone(),
     50                     e.operation_id(),
     51                     e.command_digest(),
     52                     plan,
     53                     key(),
     54                 ),
     55                 copy(&ready.proof),
     56             )
     57             .await
     58             .unwrap(),
     59     );
     60     let fields = claim.seal().unwrap().fields();
     61     let participant = keys(1);
     62     let signed = nostr::UnsignedEvent {
     63         id: Some(nostr::EventId::from_slice(&claim.seal().unwrap().event_id()).unwrap()),
     64         pubkey: participant.public_key(),
     65         created_at: nostr::Timestamp::from_secs(fields.created_at),
     66         kind: nostr::Kind::Custom(13),
     67         tags: nostr::Tags::new(),
     68         content: fields.content.to_owned(),
     69     }
     70     .sign_with_keys(&participant)
     71     .unwrap();
     72     let evidence = ArtifactEvidence::verify(&claim, &signed.as_json(), None).unwrap();
     73     assert!(matches!(
     74         ready
     75             .store
     76             .capture_evidence(ready.input.clone(), &ready.proof, &evidence)
     77             .await
     78             .unwrap(),
     79         EvidenceCaptureOutcome::Committed(_)
     80     ));
     81     assert!(matches!(
     82         ready
     83             .store
     84             .install_transition_and_outbox(
     85                 InstallationRequest::new(
     86                     ready.binding.clone(),
     87                     e.operation_id(),
     88                     e.command_digest(),
     89                     plan
     90                 ),
     91                 copy(&ready.proof)
     92             )
     93             .await
     94             .unwrap(),
     95         InstallationOutcome::Committed(_)
     96     ));
     97     let snapshot = ready
     98         .store
     99         .operation_snapshot(
    100             ready.binding.clone(),
    101             e.operation_id(),
    102             None,
    103             copy(&ready.proof),
    104         )
    105         .await
    106         .unwrap()
    107         .unwrap();
    108     assert_eq!(
    109         snapshot.installation().unwrap().transaction_id(),
    110         installation
    111     );
    112     assert_eq!(snapshot.publications().len(), 2);
    113     let work = *snapshot
    114         .publications()
    115         .iter()
    116         .find(|work| work.recipient() == key())
    117         .unwrap();
    118     let peer = keys(2);
    119     let content = nostr::nips::nip44::encrypt(
    120         peer.secret_key(),
    121         &participant.public_key(),
    122         evidence.raw_json(),
    123         nostr::nips::nip44::Version::V2,
    124     )
    125     .unwrap();
    126     let outer = nostr::UnsignedEvent {
    127         id: None,
    128         pubkey: peer.public_key(),
    129         created_at: nostr::Timestamp::from_secs(work.queued_at().get()),
    130         kind: nostr::Kind::Custom(1059),
    131         tags: nostr::Tags::from_list(vec![nostr::Tag::public_key(participant.public_key())]),
    132         content,
    133     }
    134     .sign_with_keys(&peer)
    135     .unwrap();
    136     let candidate = EnvelopeCandidate::from_obtained(
    137         work,
    138         &outer.as_json(),
    139         &peer.secret_key().to_secret_bytes(),
    140     )
    141     .unwrap();
    142     let targets = ready.request(1).intent().targets().clone();
    143     let deadline = NonZeroU64::new(work.queued_at().get() * 1000 + 60_000).unwrap();
    144     let policy = SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all());
    145     let intent = DeliveryIntent::new(
    146         &"ee".repeat(32),
    147         candidate.event_id(),
    148         &targets,
    149         &policy,
    150         deadline,
    151     )
    152     .unwrap();
    153     match ready
    154         .store
    155         .prepare_delivery_attempt(
    156             DeliveryAttemptRequest::new(ready.binding.clone(), work, intent).unwrap(),
    157             copy(&ready.proof),
    158             Some(&candidate),
    159         )
    160         .await
    161     {
    162         Err(OperationError::InvalidEvidence) => {}
    163         Ok(DeliveryAttemptOutcome::Claimed(_)) => {
    164             panic!("native D freshly claimed an outer signed by the original peer")
    165         }
    166         Err(error) => panic!("unexpected refusal: {}", error.code()),
    167         Ok(_) => panic!("unexpected retained or unknown native outcome"),
    168     }
    169     let wrapped = wrap_retained_seal(
    170         evidence.raw_json(),
    171         key(),
    172         NonZeroU64::new(work.queued_at().get()).unwrap(),
    173         &OsNonceSource,
    174     )
    175     .unwrap();
    176     let candidate = wrapped.with_wrapping_key(|key| {
    177         EnvelopeCandidate::from_obtained(work, wrapped.signed_json(), key).unwrap()
    178     });
    179     let intent = DeliveryIntent::new(
    180         &"ef".repeat(32),
    181         candidate.event_id(),
    182         &targets,
    183         &policy,
    184         deadline,
    185     )
    186     .unwrap();
    187     assert!(matches!(
    188         ready
    189             .store
    190             .prepare_delivery_attempt(
    191                 DeliveryAttemptRequest::new(ready.binding.clone(), work, intent).unwrap(),
    192                 copy(&ready.proof),
    193                 Some(&candidate)
    194             )
    195             .await
    196             .unwrap(),
    197         DeliveryAttemptOutcome::Claimed(_)
    198     ));
    199     ready.store.close().await.unwrap();
    200 }
    201 
    202 fn signed_candidate(ready: &Ready, scalar: u8, content: String) -> EnvelopeCandidate {
    203     let signer = keys(scalar);
    204     let recipient = nostr::PublicKey::from_slice(ready.work.recipient().as_bytes()).unwrap();
    205     let event = nostr::UnsignedEvent {
    206         id: None,
    207         pubkey: signer.public_key(),
    208         created_at: nostr::Timestamp::from_secs(ready.work.queued_at().get()),
    209         kind: nostr::Kind::Custom(1059),
    210         tags: nostr::Tags::from_list(vec![nostr::Tag::public_key(recipient)]),
    211         content,
    212     }
    213     .sign_with_keys(&signer)
    214     .unwrap();
    215     EnvelopeCandidate::from_obtained(
    216         ready.work,
    217         &event.as_json(),
    218         &signer.secret_key().to_secret_bytes(),
    219     )
    220     .unwrap()
    221 }
    222 async fn rebound_work(ready: &Ready) -> PublicationWork {
    223     let snapshot = ready
    224         .store
    225         .operation_snapshot(
    226             ready.binding.clone(),
    227             ready.work.evidence().operation_id(),
    228             None,
    229             copy(&ready.proof),
    230         )
    231         .await
    232         .unwrap()
    233         .unwrap();
    234     PublicationWork::from_committed_store(
    235         snapshot.bound_plan().unwrap(),
    236         snapshot.installation().unwrap(),
    237         ready.work.evidence(),
    238         TransactionId::from_bytes([91; 32]),
    239         ready.work.queued_at(),
    240     )
    241     .unwrap()
    242 }
    243 
    244 #[tokio::test]
    245 async fn native_delivery_independently_checks_temporary_keys_exact_seal_and_original_work() {
    246     let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 248).await;
    247     let receiver = nostr::PublicKey::from_slice(ready.work.recipient().as_bytes()).unwrap();
    248     let temp = keys(3);
    249     let wrong_plaintext = nostr::nips::nip44::encrypt(
    250         temp.secret_key(),
    251         &receiver,
    252         "another private record",
    253         nostr::nips::nip44::Version::V2,
    254     )
    255     .unwrap();
    256     let bad_key =
    257         EnvelopeCandidate::from_obtained(ready.work, ready.candidate.raw_json(), &[1; 32]).unwrap();
    258     let zero_key =
    259         EnvelopeCandidate::from_obtained(ready.work, ready.candidate.raw_json(), &[0; 32]).unwrap();
    260     for candidate in [
    261         signed_candidate(&ready, 1, String::from("participant outer")),
    262         signed_candidate(&ready, 2, String::from("recipient outer")),
    263         signed_candidate(&ready, 3, String::from("invalid cipher")),
    264         signed_candidate(&ready, 3, wrong_plaintext),
    265         bad_key,
    266         zero_key,
    267     ] {
    268         assert!(matches!(
    269             ready
    270                 .store
    271                 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), Some(&candidate))
    272                 .await,
    273             Err(OperationError::InvalidEvidence)
    274         ));
    275     }
    276     let work = rebound_work(&ready).await;
    277     let request = DeliveryAttemptRequest::new(
    278         ready.binding.clone(),
    279         work,
    280         ready.request(1).intent().clone(),
    281     )
    282     .unwrap();
    283     assert!(matches!(
    284         ready
    285             .store
    286             .prepare_delivery_attempt(request, copy(&ready.proof), None)
    287             .await,
    288         Err(OperationError::InvalidEvidence)
    289     ));
    290     let candidate = ready.candidate.with_wrapping_key(|key| {
    291         EnvelopeCandidate::from_obtained(work, ready.candidate.raw_json(), key).unwrap()
    292     });
    293     assert!(matches!(
    294         ready
    295             .store
    296             .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), Some(&candidate))
    297             .await,
    298         Err(OperationError::InvalidEvidence)
    299     ));
    300     let base = ready.request(1);
    301     let changed = DeliveryIntent::new(
    302         base.intent().request_id().as_str(),
    303         EnvelopeEventId::from_bytes([90; 32]),
    304         base.intent().targets(),
    305         base.intent().policy(),
    306         base.intent().deadline_unix_ms(),
    307     )
    308     .unwrap();
    309     assert!(matches!(
    310         ready
    311             .store
    312             .prepare_delivery_attempt(
    313                 DeliveryAttemptRequest::new(ready.binding.clone(), ready.work, changed).unwrap(),
    314                 copy(&ready.proof),
    315                 Some(&ready.candidate)
    316             )
    317             .await,
    318         Err(OperationError::InvalidEvidence)
    319     ));
    320     let retained = ready.retain(1).await;
    321     let replay = ready
    322         .store
    323         .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), Some(&ready.candidate))
    324         .await
    325         .unwrap();
    326     let DeliveryAttemptOutcome::Retained(replayed) = replay else {
    327         panic!("same potential invocation must never be freshly claimed")
    328     };
    329     assert_eq!(replayed.transaction_id(), retained.transaction_id());
    330     let different = ready.candidate.with_wrapping_key(|key| {
    331         EnvelopeCandidate::from_obtained(
    332             ready.work,
    333             &format!("{} ", ready.candidate.raw_json()),
    334             key,
    335         )
    336         .unwrap()
    337     });
    338     for id in [1, 2] {
    339         assert!(matches!(
    340             ready
    341                 .store
    342                 .prepare_delivery_attempt(ready.request(id), copy(&ready.proof), Some(&different))
    343                 .await,
    344             Err(OperationError::IdempotencyConflict)
    345         ));
    346     }
    347     assert_eq!(
    348         ready
    349             .query(&ready.store, retained.intent().request_id())
    350             .await
    351             .raw_json(),
    352         retained.raw_json()
    353     );
    354     ready.store.close().await.unwrap();
    355 }
    356 
    357 #[tokio::test]
    358 async fn native_delivery_refuses_backward_clock_expired_attempt_and_unbound_observations() {
    359     let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 249).await;
    360     let first = ready.retain(1).await;
    361     let time = ready.work.queued_at().get();
    362     ready.fixture.clock.now.store(time + 1, Ordering::SeqCst);
    363     assert!(matches!(
    364         ready
    365             .store
    366             .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None)
    367             .await
    368             .unwrap(),
    369         DeliveryAttemptOutcome::Claimed(_)
    370     ));
    371     ready.fixture.clock.now.store(time, Ordering::SeqCst);
    372     assert!(
    373         ready
    374             .store
    375             .prepare_delivery_attempt(ready.request(3), copy(&ready.proof), None)
    376             .await
    377             .is_err()
    378     );
    379     ready.fixture.clock.now.store(time + 61, Ordering::SeqCst);
    380     assert!(matches!(
    381         ready
    382             .store
    383             .prepare_delivery_attempt(ready.request(3), copy(&ready.proof), None)
    384             .await,
    385         Err(OperationError::DeadlineExceeded)
    386     ));
    387     for id in ["short".to_string(), "AA".repeat(32)] {
    388         let e = ready.work.evidence();
    389         assert!(matches!(
    390             ready
    391                 .store
    392                 .delivery_attempt(
    393                     ready.binding.clone(),
    394                     e.operation_id(),
    395                     e.command_digest(),
    396                     e.target(),
    397                     DeliveryRequestId::parse(id).unwrap(),
    398                     copy(&ready.proof)
    399                 )
    400                 .await,
    401             Err(OperationError::InvalidCommand)
    402         ));
    403     }
    404     let work = rebound_work(&ready).await;
    405     let target = DeliveryTargetReceipt::attempted(
    406         first.intent().targets().targets()[0].clone(),
    407         DeliveryOutcome::accepted(),
    408     );
    409     // Structural data is deliberately untrusted; these are not remote ACKs.
    410     for (reported_work, raw, ordinals) in [
    411         (work, first.raw_json().to_owned(), vec![1]),
    412         (
    413             first.work().private().unwrap(),
    414             format!("{} ", first.raw_json()),
    415             vec![1],
    416         ),
    417         (
    418             first.work().private().unwrap(),
    419             first.raw_json().to_owned(),
    420             vec![2],
    421         ),
    422     ] {
    423         let attempt = DeliveryAttempt::from_store_report(
    424             reported_work,
    425             first.intent().clone(),
    426             &raw,
    427             first.transaction_id(),
    428             first.retained_at(),
    429             ordinals,
    430         )
    431         .unwrap();
    432         let observation = DeliveryObservation::from_store_report(&attempt, &target, None).unwrap();
    433         assert!(
    434             ready
    435                 .store
    436                 .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation)
    437                 .await
    438                 .is_err()
    439         );
    440     }
    441     assert!(
    442         ready
    443             .observations(&ready.store, first.intent().request_id())
    444             .await
    445             .is_empty()
    446     );
    447     assert_eq!(
    448         ready
    449             .query(&ready.store, first.intent().request_id())
    450             .await
    451             .raw_json(),
    452         first.raw_json()
    453     );
    454     ready.store.close().await.unwrap();
    455 }
    456 
    457 #[tokio::test]
    458 async fn native_observation_query_never_crosses_original_request_or_recipient() {
    459     let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 252).await;
    460     let attempt = ready.retain(1).await;
    461     // Synthetic normalized data tests query scope; loopback cases own ACK proof.
    462     let target = DeliveryTargetReceipt::attempted(
    463         attempt.intent().targets().targets()[0].clone(),
    464         DeliveryOutcome::accepted(),
    465     );
    466     let observation = DeliveryObservation::from_store_report(&attempt, &target, None).unwrap();
    467     assert!(matches!(
    468         ready
    469             .store
    470             .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation)
    471             .await
    472             .unwrap(),
    473         DeliveryObservationOutcome::Committed(_)
    474     ));
    475     assert_eq!(
    476         ready
    477             .observations(&ready.store, attempt.intent().request_id())
    478             .await
    479             .len(),
    480         1
    481     );
    482     assert!(
    483         ready
    484             .observations(
    485                 &ready.store,
    486                 &DeliveryRequestId::parse("ab".repeat(32)).unwrap()
    487             )
    488             .await
    489             .is_empty()
    490     );
    491     let e = ready.work.evidence();
    492     assert!(
    493         ready
    494             .store
    495             .delivery_observations(
    496                 ready.binding.clone(),
    497                 e.operation_id(),
    498                 e.command_digest(),
    499                 radroots_protocol::plan::SigningTarget::BusinessSeal(key()),
    500                 attempt.intent().request_id().clone(),
    501                 copy(&ready.proof)
    502             )
    503             .await
    504             .unwrap()
    505             .is_empty()
    506     );
    507     assert_eq!(
    508         ready
    509             .observations(&ready.store, attempt.intent().request_id())
    510             .await
    511             .len(),
    512         1
    513     );
    514     ready.store.close().await.unwrap();
    515 }