lib

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

mod.rs (13274B)


      1 //! Explicit protected native outbox and fresh seller stock attachment.
      2 //!
      3 //! Fresh stock enrollment is separate from outboxes. Neither can attach a remote endpoint,
      4 //! continue an existing order or restore state from a participant key. Its
      5 //! single connection and persistent writer lock belong to one bounded worker.
      6 //! Losing an observer never drops that lock ahead of the SQLite connection.
      7 
      8 mod admission;
      9 mod attempt;
     10 mod crypto;
     11 mod delivery;
     12 mod evidence;
     13 mod fs;
     14 mod installation;
     15 mod issuance;
     16 mod listing;
     17 mod listing_installation;
     18 mod operation;
     19 mod plan;
     20 mod record;
     21 mod recovery;
     22 mod schema;
     23 mod snapshot;
     24 mod stock;
     25 pub use stock::{
     26     SellerStockConfig, StockAuthorityReceipt, StockBoundSigningPlan, StockCapturedEvidence,
     27     StockClaimOutcome, StockClaimReference, StockClaimRequest, StockConsentCapture,
     28     StockConsentMode, StockConsentOutcome, StockConsentReceipt, StockDispatchOutcome,
     29     StockDispatchPermit, StockEnrollment, StockEvidenceCapture, StockEvidencePage,
     30     StockExactReplayPermit, StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt,
     31     StockHistorySnapshot, StockInstallationOutcome, StockInstallationReceipt,
     32     StockInstallationRequest, StockListingCapture, StockListingOutcome, StockListingReceipt,
     33     StockListingSnapshot, StockOperationSnapshot, StockPublicationWork, StockRecipientSnapshot,
     34     StockReplayAdmissionReceipt, StockRequestSnapshot, StockSigningAttempt,
     35     StockSigningPlanOutcome, StockSigningPlanRequest, StockSigningProgress, StockSnapshotRequest,
     36     StockSourceCapture, StockSourceOutcome, StockSourceProfile, StockSourceReceipt,
     37     StockSourceSnapshot, StockUnissuedInvocation, StockUnissuedOutcome, StockUnissuedReceipt,
     38 };
     39 mod worker;
     40 
     41 #[cfg(test)]
     42 mod tests;
     43 
     44 pub use crypto::WorkspaceCrypto;
     45 pub use radroots_storage::workspace::{
     46     AttachmentInput, AttachmentProof, WorkspaceBinding, WorkspaceClock, WorkspaceError,
     47     WorkspaceScope,
     48 };
     49 
     50 use radroots_domain::{ExecutorId, GrantId, WorkspaceId};
     51 use radroots_storage::workspace::WorkspaceStore;
     52 use radroots_transport::BoxFuture;
     53 use std::{path::Path, sync::Arc};
     54 
     55 pub use radroots_storage::workspace::local_outbox::LocalOutboxConfig;
     56 
     57 /// One native local-outbox connection, with an owned bounded request worker.
     58 /// Clones refer to the same admission, writer authority and close completion.
     59 #[derive(Clone)]
     60 pub struct NativeWorkspace {
     61     worker: Arc<worker::Handle>,
     62 }
     63 impl NativeWorkspace {
     64     /// Creates a new owner-only namespace and persisted protected grant. All
     65     /// workspace/executor/grant IDs and the returned credential use OS entropy.
     66     /// The caller must retain both returned values through protected handling.
     67     pub async fn initialize_local_outbox(
     68         path: &Path,
     69         config: LocalOutboxConfig,
     70         crypto: WorkspaceCrypto,
     71         clock: Arc<dyn WorkspaceClock>,
     72     ) -> Result<(Self, AttachmentInput, AttachmentProof), WorkspaceError> {
     73         let now = clock.now()?;
     74         config.validate_at(now)?;
     75         let secret = zeroize::Zeroizing::new(random()?);
     76         let proof = AttachmentProof::from_protected_input(secret.as_ref())?;
     77         let (input, proof, record) = config.enroll(
     78             now,
     79             WorkspaceId::from_bytes(random()?),
     80             ExecutorId::from_bytes(random()?),
     81             GrantId::from_bytes(random()?),
     82             proof,
     83         )?;
     84         let worker = worker::Handle::launch(
     85             path.to_path_buf(),
     86             input.clone(),
     87             Some(record),
     88             crypto,
     89             clock,
     90         )
     91         .await?;
     92         Ok((
     93             Self {
     94                 worker: Arc::new(worker),
     95             },
     96             input,
     97             proof,
     98         ))
     99     }
    100     /// Opens only an existing exact namespace. The independently retained
    101     /// selection supplies the expected envelope context; no grant is created.
    102     pub async fn open_existing(
    103         path: &Path,
    104         expected: AttachmentInput,
    105         crypto: WorkspaceCrypto,
    106         clock: Arc<dyn WorkspaceClock>,
    107     ) -> Result<Self, WorkspaceError> {
    108         let worker =
    109             worker::Handle::launch(path.to_path_buf(), expected, None, crypto, clock).await?;
    110         Ok(Self {
    111             worker: Arc::new(worker),
    112         })
    113     }
    114     /// Authenticates and revokes this exact local grant. A cancelled observer
    115     /// must query its retained identity; it cannot presume the write aborted.
    116     pub async fn revoke(
    117         &self,
    118         input: AttachmentInput,
    119         proof: &AttachmentProof,
    120     ) -> Result<(), WorkspaceError> {
    121         self.worker.revoke(input, proof).await
    122     }
    123     /// Copies an explicitly borrowed protected credential into one owned
    124     /// bounded authentication request. The caller retains its original input.
    125     pub async fn authenticate(
    126         &self,
    127         input: AttachmentInput,
    128         proof: &AttachmentProof,
    129     ) -> Result<WorkspaceBinding, WorkspaceError> {
    130         let proof = proof.with_secret(|secret| AttachmentProof::from_protected_input(secret))?;
    131         self.worker.authenticate(input, proof).await
    132     }
    133     /// Permanently closes admission, drains admitted requests and explicitly
    134     /// closes SQLite before releasing the persistent writer authority.
    135     pub async fn close(&self) -> Result<(), WorkspaceError> {
    136         self.worker.close().await
    137     }
    138 }
    139 impl std::fmt::Debug for NativeWorkspace {
    140     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    141         f.write_str("NativeWorkspace(<redacted>)")
    142     }
    143 }
    144 impl WorkspaceStore for NativeWorkspace {
    145     fn authenticate(
    146         &self,
    147         input: AttachmentInput,
    148         proof: AttachmentProof,
    149     ) -> BoxFuture<'_, Result<WorkspaceBinding, WorkspaceError>> {
    150         Box::pin(self.worker.authenticate(input, proof))
    151     }
    152     fn close_workspace(&self) -> BoxFuture<'_, Result<(), WorkspaceError>> {
    153         Box::pin(self.close())
    154     }
    155 }
    156 impl radroots_storage::command::OperationJournal for NativeWorkspace {
    157     fn reconcile_unknown<'a>(
    158         &'a self,
    159         input: AttachmentInput,
    160         proof: &'a AttachmentProof,
    161         evidence: &'a radroots_storage::command::ArtifactEvidence,
    162     ) -> BoxFuture<
    163         'a,
    164         Result<
    165             radroots_storage::command::EvidenceCaptureOutcome,
    166             radroots_storage::command::OperationError,
    167         >,
    168     > {
    169         Box::pin(self.worker.reconcile_unknown(input, proof, evidence))
    170     }
    171     fn record_delivery_observation(
    172         &self,
    173         binding: WorkspaceBinding,
    174         proof: AttachmentProof,
    175         observation: radroots_storage::command::DeliveryObservation,
    176     ) -> BoxFuture<
    177         '_,
    178         Result<
    179             radroots_storage::command::DeliveryObservationOutcome,
    180             radroots_storage::command::OperationError,
    181         >,
    182     > {
    183         Box::pin(
    184             self.worker
    185                 .capture_delivery_observation(binding, proof, observation),
    186         )
    187     }
    188     fn delivery_observations(
    189         &self,
    190         binding: WorkspaceBinding,
    191         operation: radroots_domain::OperationId,
    192         digest: radroots_domain::CommandDigest,
    193         target: radroots_storage::command::SigningTarget,
    194         request: radroots_transport::sink::DeliveryRequestId,
    195         proof: AttachmentProof,
    196     ) -> BoxFuture<
    197         '_,
    198         Result<
    199             Vec<radroots_storage::command::DeliveryObservation>,
    200             radroots_storage::command::OperationError,
    201         >,
    202     > {
    203         Box::pin(
    204             self.worker
    205                 .query_delivery_observations(binding, operation, digest, target, request, proof),
    206         )
    207     }
    208     fn prepare_delivery_attempt<'a>(
    209         &'a self,
    210         request: radroots_storage::command::DeliveryAttemptRequest,
    211         proof: AttachmentProof,
    212         candidate: Option<&'a radroots_storage::command::EnvelopeCandidate>,
    213     ) -> BoxFuture<
    214         'a,
    215         Result<
    216             radroots_storage::command::DeliveryAttemptOutcome,
    217             radroots_storage::command::OperationError,
    218         >,
    219     > {
    220         Box::pin(self.worker.prepare_delivery(request, proof, candidate))
    221     }
    222     fn delivery_attempt(
    223         &self,
    224         binding: WorkspaceBinding,
    225         operation: radroots_domain::OperationId,
    226         digest: radroots_domain::CommandDigest,
    227         target: radroots_storage::command::SigningTarget,
    228         request: radroots_transport::sink::DeliveryRequestId,
    229         proof: AttachmentProof,
    230     ) -> BoxFuture<
    231         '_,
    232         Result<
    233             Option<radroots_storage::command::DeliveryAttempt>,
    234             radroots_storage::command::OperationError,
    235         >,
    236     > {
    237         Box::pin(
    238             self.worker
    239                 .query_delivery(binding, operation, digest, target, request, proof),
    240         )
    241     }
    242     fn install_transition_and_outbox(
    243         &self,
    244         request: radroots_storage::command::InstallationRequest,
    245         proof: AttachmentProof,
    246     ) -> BoxFuture<
    247         '_,
    248         Result<
    249             radroots_storage::command::InstallationOutcome,
    250             radroots_storage::command::OperationError,
    251         >,
    252     > {
    253         Box::pin(self.worker.install_chat(request, proof))
    254     }
    255     fn operation_snapshot(
    256         &self,
    257         binding: WorkspaceBinding,
    258         operation_id: radroots_domain::OperationId,
    259         expected_digest: Option<radroots_domain::CommandDigest>,
    260         proof: AttachmentProof,
    261     ) -> BoxFuture<
    262         '_,
    263         Result<
    264             Option<radroots_storage::command::OperationSnapshot>,
    265             radroots_storage::command::OperationError,
    266         >,
    267     > {
    268         Box::pin(
    269             self.worker
    270                 .operation_snapshot(binding, operation_id, expected_digest, proof),
    271         )
    272     }
    273     fn claim_attempt(
    274         &self,
    275         request: radroots_storage::command::ClaimAttemptRequest,
    276         proof: AttachmentProof,
    277     ) -> BoxFuture<
    278         '_,
    279         Result<
    280             radroots_storage::command::ClaimAttemptOutcome,
    281             radroots_storage::command::OperationError,
    282         >,
    283     > {
    284         Box::pin(self.worker.claim_attempt(request, proof))
    285     }
    286     fn signing_attempt(
    287         &self,
    288         request: radroots_storage::command::ClaimAttemptRequest,
    289         proof: AttachmentProof,
    290     ) -> BoxFuture<
    291         '_,
    292         Result<
    293             Option<radroots_storage::command::SigningAttempt>,
    294             radroots_storage::command::OperationError,
    295         >,
    296     > {
    297         Box::pin(self.worker.signing_attempt(request, proof))
    298     }
    299     fn capture_evidence<'a>(
    300         &'a self,
    301         input: AttachmentInput,
    302         proof: &'a AttachmentProof,
    303         evidence: &'a radroots_storage::command::ArtifactEvidence,
    304     ) -> BoxFuture<
    305         'a,
    306         Result<
    307             radroots_storage::command::EvidenceCaptureOutcome,
    308             radroots_storage::command::OperationError,
    309         >,
    310     > {
    311         Box::pin(self.worker.capture_evidence(input, proof, evidence))
    312     }
    313     fn obtained_evidence(
    314         &self,
    315         request: radroots_storage::command::ClaimAttemptRequest,
    316         proof: AttachmentProof,
    317     ) -> BoxFuture<
    318         '_,
    319         Result<
    320             Option<radroots_storage::command::CapturedArtifact>,
    321             radroots_storage::command::OperationError,
    322         >,
    323     > {
    324         Box::pin(self.worker.obtained_evidence(request, proof))
    325     }
    326 
    327     fn bind_signing_intents(
    328         &self,
    329         binding: WorkspaceBinding,
    330         plan: radroots_storage::command::CapturedSigningPlan,
    331         proof: AttachmentProof,
    332     ) -> BoxFuture<
    333         '_,
    334         Result<
    335             radroots_storage::command::PlanBindingOutcome,
    336             radroots_storage::command::OperationError,
    337         >,
    338     > {
    339         Box::pin(self.worker.bind_plan(binding, plan, proof))
    340     }
    341     fn signing_plan(
    342         &self,
    343         binding: WorkspaceBinding,
    344         operation_id: radroots_domain::OperationId,
    345         digest: radroots_domain::CommandDigest,
    346         proof: AttachmentProof,
    347     ) -> BoxFuture<
    348         '_,
    349         Result<
    350             Option<radroots_storage::command::BoundSigningPlan>,
    351             radroots_storage::command::OperationError,
    352         >,
    353     > {
    354         Box::pin(
    355             self.worker
    356                 .signing_plan(binding, operation_id, digest, proof),
    357         )
    358     }
    359     fn admit_command_and_hold(
    360         &self,
    361         request: radroots_storage::command::AdmissionRequest,
    362         proof: AttachmentProof,
    363     ) -> BoxFuture<
    364         '_,
    365         Result<
    366             radroots_storage::command::AdmissionOutcome,
    367             radroots_storage::command::OperationError,
    368         >,
    369     > {
    370         Box::pin(self.worker.admit(request, proof))
    371     }
    372     fn operation(
    373         &self,
    374         binding: WorkspaceBinding,
    375         operation_id: radroots_domain::OperationId,
    376         digest: Option<radroots_domain::CommandDigest>,
    377         proof: AttachmentProof,
    378     ) -> BoxFuture<
    379         '_,
    380         Result<
    381             Option<radroots_storage::command::PreparedOperation>,
    382             radroots_storage::command::OperationError,
    383         >,
    384     > {
    385         Box::pin(self.worker.operation(binding, operation_id, digest, proof))
    386     }
    387 }
    388 fn random() -> Result<[u8; 32], WorkspaceError> {
    389     let mut value = [0; 32];
    390     getrandom::getrandom(&mut value).map_err(|_| WorkspaceError::Unavailable)?;
    391     Ok(value)
    392 }