lib

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

command.rs (7260B)


      1 #![cfg(feature = "command_journal")]
      2 
      3 use radroots_domain::{
      4     ActorRef, ActorRole, AuthorityRef, CheckpointDigest, CheckpointRef, CommandContextData,
      5     Coverage, ExecutorId, Generation, GrantId, OperationId, PublicKey, RouteDigest, Sequence,
      6     TransactionId, UnixSeconds, WorkspaceId,
      7 };
      8 use radroots_storage::{
      9     command::{AdmissionRequest, CommitAttempt, OperationError, PreparedOperation},
     10     workspace::{AttachmentInput, WorkspaceBinding, WorkspaceError},
     11 };
     12 
     13 fn binding() -> WorkspaceBinding {
     14     let key =
     15         PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798")
     16             .unwrap();
     17     let grant = GrantId::from_bytes([3; 32]);
     18     let input = AttachmentInput::new(
     19         WorkspaceId::from_bytes([1; 32]),
     20         AuthorityRef::new(ExecutorId::from_bytes([2; 32]), Generation::new(1).unwrap()),
     21         key,
     22         "local://workspace/selector",
     23         key,
     24         grant,
     25         CheckpointRef::new(
     26             CheckpointDigest::from_bytes([4; 32]),
     27             Sequence::new(0).unwrap(),
     28             Coverage::Partial,
     29             vec![],
     30         )
     31         .unwrap(),
     32         RouteDigest::from_bytes([5; 32]),
     33     )
     34     .unwrap();
     35     WorkspaceBinding::from_authenticated_host(
     36         input,
     37         radroots_storage::workspace::WorkspaceScope::NewBuyerOutbox,
     38         ActorRef::new(key, ActorRole::Buyer, None, Some(grant)),
     39         "device",
     40         Sequence::new(1).unwrap(),
     41         UnixSeconds::new(200).unwrap(),
     42         UnixSeconds::new(100).unwrap(),
     43     )
     44     .unwrap()
     45 }
     46 fn request() -> AdmissionRequest {
     47     request_until(150)
     48 }
     49 fn request_until(not_after: u64) -> AdmissionRequest {
     50     let binding = binding();
     51     let input = binding.input();
     52     let context = CommandContextData::new(
     53         OperationId::from_bytes([6; 32]),
     54         binding.actor(),
     55         input.workspace_id(),
     56         input.authority(),
     57         input.route_digest(),
     58         None,
     59         None,
     60         UnixSeconds::new(not_after).unwrap(),
     61         None,
     62     )
     63     .unwrap();
     64     let command = radroots_protocol::command::CapturedChatCommand::inquire(
     65         context,
     66         radroots_protocol::command::InquireInput::new(
     67             radroots_domain::ThreadId::from_bytes([7; 32]),
     68             input.participant(),
     69             None,
     70             "private field",
     71         )
     72         .unwrap(),
     73     )
     74     .unwrap();
     75     AdmissionRequest::new(binding, command).unwrap()
     76 }
     77 
     78 #[test]
     79 fn retained_window_cannot_precede_attachment_or_exceed_command_or_grant() {
     80     for (prepared, deadline, authorization) in [(99, 150, 150), (100, 151, 150), (100, 201, 300)] {
     81         let window = radroots_domain::IssuanceWindow::new(
     82             UnixSeconds::new(prepared).unwrap(),
     83             UnixSeconds::new(deadline).unwrap(),
     84         )
     85         .unwrap();
     86         assert!(matches!(
     87             PreparedOperation::from_committed_store(
     88                 request_until(authorization),
     89                 TransactionId::from_bytes([8; 32]),
     90                 Sequence::new(1).unwrap(),
     91                 window,
     92             ),
     93             Err(OperationError::RecoveryRequired)
     94         ));
     95     }
     96 }
     97 
     98 #[test]
     99 fn structural_reports_preserve_full_original_anchor_without_minting_commit_proof() {
    100     let captured = request();
    101     let digest = captured.command().digest();
    102     let wire = captured.command().protected_wire().to_vec();
    103     let (binding, command) = captured.into_parts();
    104     assert_eq!(command.protected_wire(), wire);
    105     let parsed = AdmissionRequest::from_protected_wire(binding, &wire).unwrap();
    106     let transaction = TransactionId::from_bytes([8; 32]);
    107     assert!(matches!(
    108         PreparedOperation::from_committed_store(
    109             request(),
    110             transaction,
    111             Sequence::new(0).unwrap(),
    112             radroots_domain::IssuanceWindow::capture(
    113                 UnixSeconds::new(100).unwrap(),
    114                 UnixSeconds::new(150).unwrap()
    115             )
    116             .unwrap()
    117         ),
    118         Err(OperationError::RecoveryRequired)
    119     ));
    120     let reported = PreparedOperation::from_committed_store(
    121         parsed,
    122         transaction,
    123         Sequence::new(1).unwrap(),
    124         radroots_domain::IssuanceWindow::capture(
    125             UnixSeconds::new(100).unwrap(),
    126             UnixSeconds::new(150).unwrap(),
    127         )
    128         .unwrap(),
    129     )
    130     .unwrap();
    131     let anchor = reported.identity();
    132     assert_eq!(reported.transaction_id(), transaction);
    133     assert_eq!(reported.revision().get(), 1);
    134     assert_eq!(
    135         anchor.workspace_id(),
    136         reported.request().binding().input().workspace_id()
    137     );
    138     assert_eq!(anchor.operation_id(), OperationId::from_bytes([6; 32]));
    139     assert_eq!(anchor.command_digest(), digest);
    140     assert_eq!(anchor.transaction_id(), Some(transaction));
    141     assert_eq!(
    142         CommitAttempt::new(anchor.workspace_id(), anchor.operation_id(), digest, None)
    143             .transaction_id(),
    144         None
    145     );
    146     assert!(!format!("{reported:?}").contains("private field"));
    147 }
    148 
    149 #[test]
    150 fn a_data_constructor_refuses_substituted_scope_but_never_authenticates_descriptors() {
    151     let original = request();
    152     let wire: serde_json::Value =
    153         serde_json::from_slice(original.command().protected_wire()).unwrap();
    154     for (pointer, value) in [
    155         ("/context/workspace_id", serde_json::json!("99".repeat(32))),
    156         ("/context/authority/generation", serde_json::json!("2")),
    157         ("/context/route_digest", serde_json::json!("99".repeat(32))),
    158         ("/context/actor/role", serde_json::json!("seller")),
    159     ] {
    160         let mut changed = wire.clone();
    161         *changed.pointer_mut(pointer).unwrap() = value;
    162         assert!(matches!(
    163             AdmissionRequest::from_protected_wire(
    164                 binding(),
    165                 &serde_json::to_vec(&changed).unwrap()
    166             ),
    167             Err(OperationError::InvalidCommand)
    168         ));
    169     }
    170     assert!(matches!(
    171         AdmissionRequest::from_protected_wire(binding(), b"{bad}"),
    172         Err(OperationError::RecoveryRequired)
    173     ));
    174     assert!(!format!("{original:?}").contains("private field"));
    175 }
    176 
    177 #[test]
    178 fn operation_failures_are_fixed_redacted_and_distinguish_uncertainty() {
    179     let errors = [
    180         OperationError::from(WorkspaceError::Closed),
    181         OperationError::InvalidCommand,
    182         OperationError::Unauthorized,
    183         OperationError::MissingHistory,
    184         OperationError::UnverifiedApproval,
    185         OperationError::DeadlineExceeded,
    186         OperationError::IdempotencyConflict,
    187         OperationError::StorageFailure,
    188         OperationError::RecoveryRequired,
    189     ];
    190     let mut codes = std::collections::BTreeSet::new();
    191     for error in errors {
    192         assert!(codes.insert(error.code()));
    193         assert!(error.to_string().len() < 64);
    194         assert_eq!(error.to_string(), error.code());
    195         assert!(std::error::Error::source(&error).is_none());
    196     }
    197     let attempt = CommitAttempt::new(
    198         WorkspaceId::from_bytes([1; 32]),
    199         OperationId::from_bytes([2; 32]),
    200         radroots_domain::CommandDigest::from_bytes([3; 32]),
    201         None,
    202     );
    203     assert_eq!(
    204         format!(
    205             "{:?}",
    206             radroots_storage::command::AdmissionOutcome::Unknown(attempt)
    207         ),
    208         "AdmissionOutcome::Unknown(<retained>)"
    209     );
    210 }