lib

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

inventory_envelope.rs (5822B)


      1 //! Shape checks remain independent of concrete persistence and permission.
      2 #[path = "inventory_delivery.rs"]
      3 mod delivery;
      4 use super::*;
      5 use radroots_domain::{
      6     CommandDigest, EnvelopeEventId, OperationId, SigningAttemptId, TransactionId,
      7 };
      8 use radroots_storage::{
      9     command::{CommitAttempt, OperationError},
     10     inventory::{
     11         InventoryCheckpointRef, StockEnvelopeReceipt, StockEnvelopeRequest, StockEvidenceReceipt,
     12     },
     13     workspace::WorkspaceScope,
     14 };
     15 
     16 fn binding(scope: WorkspaceScope) -> WorkspaceBinding {
     17     WorkspaceBinding::from_authenticated_host(
     18         input(),
     19         scope,
     20         ActorRef::new(key(), ActorRole::Seller, None, Some(input().grant_id())),
     21         "synthetic",
     22         Sequence::new(1).unwrap(),
     23         UnixSeconds::new(200).unwrap(),
     24         UnixSeconds::new(100).unwrap(),
     25     )
     26     .unwrap()
     27 }
     28 fn checkpoint(revision: u64) -> InventoryCheckpointRef {
     29     InventoryCheckpointRef::from_host_metadata(
     30         input().authority(),
     31         Sequence::new(revision).unwrap(),
     32         (revision != 0).then_some(CheckpointDigest::from_bytes([13; 32])),
     33     )
     34     .unwrap()
     35 }
     36 fn attempt(workspace: u8, operation: u8, digest: u8, committed: bool) -> CommitAttempt {
     37     CommitAttempt::new(
     38         WorkspaceId::from_bytes([workspace; 32]),
     39         OperationId::from_bytes([operation; 32]),
     40         CommandDigest::from_bytes([digest; 32]),
     41         committed.then_some(TransactionId::from_bytes([11; 32])),
     42     )
     43 }
     44 fn evidence(attempt: CommitAttempt, recipient: PublicKey) -> StockEvidenceReceipt {
     45     StockEvidenceReceipt::from_committed_store(
     46         attempt,
     47         SigningAttemptId::from_bytes([9; 32]),
     48         recipient,
     49         [10; 32],
     50         None,
     51     )
     52     .unwrap()
     53 }
     54 
     55 #[test]
     56 fn envelope_selector_refuses_foreign_authority_and_non_stock_scope_without_minting_a_transaction() {
     57     let select = |scope, minimum| {
     58         StockEnvelopeRequest::new(
     59             binding(scope),
     60             minimum,
     61             OperationId::from_bytes([7; 32]),
     62             CommandDigest::from_bytes([8; 32]),
     63             key(),
     64             None,
     65         )
     66     };
     67     assert!(matches!(
     68         select(WorkspaceScope::NewSellerOutbox, checkpoint(0)),
     69         Err(OperationError::Unauthorized)
     70     ));
     71     let foreign = InventoryCheckpointRef::from_host_metadata(
     72         AuthorityRef::new(
     73             ExecutorId::from_bytes([99; 32]),
     74             Generation::new(1).unwrap(),
     75         ),
     76         Sequence::new(0).unwrap(),
     77         None,
     78     )
     79     .unwrap();
     80     assert!(select(WorkspaceScope::SellerStockOwner, foreign).is_err());
     81     let request = select(WorkspaceScope::SellerStockOwner, checkpoint(0)).unwrap();
     82     assert_eq!(request.minimum_checkpoint(), checkpoint(0));
     83     assert_eq!(request.attempt(), attempt(1, 7, 8, false));
     84     assert!(request.observed_at_unix_ms().is_none());
     85     assert_eq!(format!("{request:?}"), "StockEnvelopeRequest(<redacted>)");
     86 }
     87 
     88 #[test]
     89 fn envelope_report_rejects_mixed_originals_and_preserves_nullable_capture_observation() {
     90     let original = attempt(1, 7, 8, true);
     91     let source = evidence(original, key());
     92     let peer =
     93         PublicKey::from_hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5")
     94             .unwrap();
     95     for observed in [None, core::num::NonZeroU64::new(150000)] {
     96         let request = StockEnvelopeRequest::new(
     97             binding(WorkspaceScope::SellerStockOwner),
     98             checkpoint(0),
     99             original.operation_id(),
    100             original.command_digest(),
    101             key(),
    102             observed,
    103         )
    104         .unwrap();
    105         let report = |anchor, obtained, progress| {
    106             StockEnvelopeReceipt::from_committed_store(
    107                 &request,
    108                 anchor,
    109                 obtained,
    110                 TransactionId::from_bytes([12; 32]),
    111                 EnvelopeEventId::from_bytes([14; 32]),
    112                 [15; 32],
    113                 progress,
    114             )
    115         };
    116         for anchor in [
    117             attempt(1, 7, 8, false),
    118             attempt(99, 7, 8, true),
    119             attempt(1, 99, 8, true),
    120             attempt(1, 7, 99, true),
    121         ] {
    122             assert_eq!(
    123                 report(anchor, source, checkpoint(1)).unwrap_err(),
    124                 OperationError::RecoveryRequired
    125             );
    126         }
    127         for obtained in [
    128             evidence(attempt(99, 7, 8, true), key()),
    129             evidence(attempt(1, 99, 8, true), key()),
    130             evidence(attempt(1, 7, 99, true), key()),
    131             evidence(original, peer),
    132         ] {
    133             assert_eq!(
    134                 report(original, obtained, checkpoint(1)).unwrap_err(),
    135                 OperationError::RecoveryRequired
    136             );
    137         }
    138         assert!(report(original, source, checkpoint(0)).is_err());
    139         let foreign = InventoryCheckpointRef::from_host_metadata(
    140             AuthorityRef::new(
    141                 ExecutorId::from_bytes([99; 32]),
    142                 Generation::new(1).unwrap(),
    143             ),
    144             checkpoint(1).revision(),
    145             checkpoint(1).head(),
    146         )
    147         .unwrap();
    148         assert!(report(original, source, foreign).is_err());
    149         let retained = report(original, source, checkpoint(1)).unwrap();
    150         assert_eq!(retained.attempt(), original);
    151         assert_eq!(retained.evidence(), source);
    152         assert_eq!(retained.recipient(), key());
    153         assert_eq!(
    154             retained.installation_transaction_id(),
    155             TransactionId::from_bytes([12; 32])
    156         );
    157         assert_eq!(retained.event_id(), EnvelopeEventId::from_bytes([14; 32]));
    158         assert_eq!(retained.digest(), &[15; 32]);
    159         assert_eq!(retained.checkpoint(), checkpoint(1));
    160         assert_eq!(retained.observed_at_unix_ms(), observed);
    161         assert_eq!(format!("{retained:?}"), "StockEnvelopeReceipt(<redacted>)");
    162     }
    163 }