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 }