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 }