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 }