lib

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

inventory_evidence.rs (3451B)


      1 //! These are bounded descriptors and report-shape checks, not store proofs.
      2 use super::*;
      3 use radroots_domain::{CommandDigest, OperationId, SigningAttemptId, TransactionId};
      4 use radroots_storage::{
      5     command::{CommitAttempt, OperationError},
      6     inventory::{StockEvidenceReceipt, StockEvidenceRequest},
      7     workspace::WorkspaceScope,
      8 };
      9 fn binding(scope: WorkspaceScope) -> WorkspaceBinding {
     10     WorkspaceBinding::from_authenticated_host(
     11         input(),
     12         scope,
     13         ActorRef::new(key(), ActorRole::Seller, None, Some(input().grant_id())),
     14         "synthetic",
     15         Sequence::new(1).unwrap(),
     16         UnixSeconds::new(200).unwrap(),
     17         UnixSeconds::new(100).unwrap(),
     18     )
     19     .unwrap()
     20 }
     21 fn request(scope: WorkspaceScope, raw: &str) -> Result<StockEvidenceRequest, OperationError> {
     22     StockEvidenceRequest::from_obtained_wire(
     23         binding(scope),
     24         OperationId::from_bytes([7; 32]),
     25         CommandDigest::from_bytes([8; 32]),
     26         SigningAttemptId::from_bytes([9; 32]),
     27         key(),
     28         [10; 32],
     29         raw,
     30         None,
     31     )
     32 }
     33 #[test]
     34 fn input_bounds_original_identity_and_redaction_hold_without_authenticating_a_claim() {
     35     for raw in ["".to_owned(), "x".repeat(65537), "é".repeat(32769)] {
     36         assert!(matches!(
     37             request(WorkspaceScope::SellerStockOwner, &raw),
     38             Err(OperationError::InvalidEvidence)
     39         ));
     40     }
     41     assert!(request(WorkspaceScope::NewSellerOutbox, "x").is_err());
     42     let raw = "x".repeat(65536);
     43     let evidence = request(WorkspaceScope::SellerStockOwner, &raw).unwrap();
     44     let retained = evidence.retained_copy();
     45     drop(evidence);
     46     retained.with_json(|value| assert_eq!(value, raw));
     47     assert!(!format!("{retained:?}").contains(&raw));
     48     assert_eq!(retained.attempt().workspace_id(), input().workspace_id());
     49     assert_eq!(retained.attempt().operation_id(), retained.operation_id());
     50     assert_eq!(
     51         retained.attempt().command_digest(),
     52         retained.command_digest()
     53     );
     54     assert!(retained.attempt().transaction_id().is_none());
     55     assert_eq!(
     56         retained.signing_attempt_id(),
     57         SigningAttemptId::from_bytes([9; 32])
     58     );
     59     assert_eq!(retained.recipient(), key());
     60     assert_eq!(retained.intent_digest(), &[10; 32]);
     61     assert!(retained.observed_at_unix_ms().is_none());
     62 }
     63 #[test]
     64 fn append_report_requires_commit_identity_and_preserves_nullable_observation() {
     65     let attempt = |transaction| {
     66         CommitAttempt::new(
     67             input().workspace_id(),
     68             OperationId::from_bytes([7; 32]),
     69             CommandDigest::from_bytes([8; 32]),
     70             transaction,
     71         )
     72     };
     73     let claim = SigningAttemptId::from_bytes([9; 32]);
     74     assert_eq!(
     75         StockEvidenceReceipt::from_committed_store(attempt(None), claim, key(), [10; 32], None)
     76             .unwrap_err(),
     77         OperationError::RecoveryRequired
     78     );
     79     for observed in [None, core::num::NonZeroU64::new(150000)] {
     80         let original = attempt(Some(TransactionId::from_bytes([11; 32])));
     81         let report =
     82             StockEvidenceReceipt::from_committed_store(original, claim, key(), [10; 32], observed)
     83                 .unwrap();
     84         assert_eq!(report.attempt(), original);
     85         assert_eq!(report.signing_attempt_id(), claim);
     86         assert_eq!(report.recipient(), key());
     87         assert_eq!(report.digest(), &[10; 32]);
     88         assert_eq!(report.observed_at_unix_ms(), observed);
     89     }
     90 }