stock.rs (61103B)
1 //! Fresh native stock authority. No allocation or issuance is implied by enrollment. 2 use super::{ 3 AttachmentInput, AttachmentProof, NativeWorkspace, WorkspaceBinding, WorkspaceClock, 4 WorkspaceCrypto, WorkspaceError, WorkspaceScope, fs::Namespace, record::GrantRecord, 5 }; 6 use radroots_domain::{ExecutorId, GrantId, Sequence, TransactionId, WorkspaceId}; 7 pub use radroots_storage::workspace::seller_stock::SellerStockConfig; 8 use radroots_storage::workspace::seller_stock::{ 9 SellerAuthoritySelection, StockAction, StockAuthorizationRef, StockGrantRecord, StockGrantScope, 10 }; 11 pub(in crate::workspace) mod consent; 12 pub(in crate::workspace) mod delivery; 13 pub use consent::{ 14 StockConsentCapture, StockConsentMode, StockConsentOutcome, StockConsentReceipt, 15 }; 16 pub(in crate::workspace) mod grants; 17 pub use inventory::installation::{ 18 StockInstallationOutcome, StockInstallationReceipt, StockInstallationRequest, 19 StockPublicationWork, 20 }; 21 pub(in crate::workspace) use radroots_storage::inventory::{ 22 StockAbortOutcome, StockAbortReceipt, StockAbortRequest, StockEvidenceOutcome, 23 StockEvidenceReceipt, StockEvidenceRequest, 24 }; 25 pub(in crate::workspace) use radroots_storage::inventory::{ 26 StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, 27 }; 28 pub(in crate::workspace) mod issuance; 29 mod ledger; 30 mod order_state; 31 pub use issuance::{ 32 StockCapturedEvidence, StockClaimOutcome, StockClaimRequest, StockDispatchOutcome, 33 StockDispatchPermit, StockEvidenceCapture, StockEvidencePage, StockExactReplayPermit, 34 StockReplayAdmissionReceipt, StockSigningAttempt, StockUnissuedInvocation, 35 StockUnissuedOutcome, StockUnissuedReceipt, 36 }; 37 pub(in crate::workspace) mod signing_plan; 38 pub(in crate::workspace) mod snapshot; 39 pub use signing_plan::{StockBoundSigningPlan, StockSigningPlanOutcome, StockSigningPlanRequest}; 40 pub use snapshot::{ 41 StockClaimReference, StockOperationSnapshot, StockRecipientSnapshot, StockSigningProgress, 42 StockSnapshotRequest, 43 }; 44 pub(in crate::workspace) mod public_source; 45 pub use public_source::{ 46 StockListingCapture, StockListingOutcome, StockListingReceipt, StockListingSnapshot, 47 }; 48 pub(in crate::workspace) mod source; 49 use grants::StockRecord; 50 pub use grants::{StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt}; 51 use serde::{Deserialize, Serialize}; 52 pub use source::{ 53 StockHistorySnapshot, StockRequestSnapshot, StockSourceCapture, StockSourceOutcome, 54 StockSourceProfile, StockSourceReceipt, StockSourceSnapshot, 55 }; 56 use sqlx::{Connection, SqliteConnection}; 57 use std::{ 58 path::Path, 59 sync::{Arc, Mutex}, 60 }; 61 62 /// One-shot protected enrollment, retained before starting durable creation. A lost 63 /// observer must reopen its original selection, never silently create a replacement. 64 pub struct StockEnrollment { 65 input: AttachmentInput, 66 proof: AttachmentProof, 67 record: Mutex<Option<GrantRecord>>, 68 transaction: TransactionId, 69 } 70 impl StockEnrollment { 71 pub fn prepare( 72 config: SellerStockConfig, 73 clock: &dyn WorkspaceClock, 74 ) -> Result<Self, WorkspaceError> { 75 let now = clock.now()?; 76 config.validate_at(now)?; 77 let secret = zeroize::Zeroizing::new(super::random()?); 78 let proof = AttachmentProof::from_protected_input(secret.as_ref())?; 79 let (input, proof, record) = config.enroll( 80 now, 81 WorkspaceId::from_bytes(super::random()?), 82 ExecutorId::from_bytes(super::random()?), 83 GrantId::from_bytes(super::random()?), 84 proof, 85 )?; 86 Ok(Self { 87 input, 88 proof, 89 record: Mutex::new(Some(record)), 90 transaction: TransactionId::from_bytes(super::random()?), 91 }) 92 } 93 pub fn input(&self) -> &AttachmentInput { 94 &self.input 95 } 96 pub fn proof(&self) -> &AttachmentProof { 97 &self.proof 98 } 99 pub const fn transaction_id(&self) -> TransactionId { 100 self.transaction 101 } 102 } 103 impl std::fmt::Debug for StockEnrollment { 104 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 105 f.write_str("StockEnrollment(<redacted>)") 106 } 107 } 108 /// A confirmed creation identity read from protected durable state. This is 109 /// enrollment evidence, not proof of any stock quantity or business operation. 110 #[derive(Clone, Debug, Eq, PartialEq)] 111 pub struct StockAuthorityReceipt { 112 pub(super) input: AttachmentInput, 113 pub(super) transaction: TransactionId, 114 pub(super) revocation: Sequence, 115 pub(super) inventory: Option<radroots_storage::inventory::InventoryCheckpointRef>, 116 pub(super) sources: Option<radroots_storage::workspace::seller_stock::StockSourceCheckpointRef>, 117 pub(super) public_sources: 118 Option<radroots_storage::workspace::seller_stock::StockListingCheckpointRef>, 119 } 120 impl StockAuthorityReceipt { 121 /// Independently retained public observation progress; this certifies no 122 /// global head, profile readiness or business permission. 123 pub const fn listing_checkpoint( 124 &self, 125 ) -> Option<radroots_storage::workspace::seller_stock::StockListingCheckpointRef> { 126 self.public_sources 127 } 128 /// Separately retained source progress; profile recognition proves no order 129 /// actionability. Absent for retained catalogs without source retention. 130 pub const fn source_checkpoint( 131 &self, 132 ) -> Option<radroots_storage::workspace::seller_stock::StockSourceCheckpointRef> { 133 self.sources 134 } 135 pub fn input(&self) -> &AttachmentInput { 136 &self.input 137 } 138 pub const fn transaction_id(&self) -> TransactionId { 139 self.transaction 140 } 141 /// Current protected inventory checkpoint, absent for enrollment-only catalogs. 142 pub const fn inventory_checkpoint( 143 &self, 144 ) -> Option<radroots_storage::inventory::InventoryCheckpointRef> { 145 self.inventory 146 } 147 pub const fn revocation_generation(&self) -> Sequence { 148 self.revocation 149 } 150 } 151 impl NativeWorkspace { 152 pub async fn initialize_seller_stock( 153 path: &Path, 154 enrollment: &StockEnrollment, 155 crypto: WorkspaceCrypto, 156 clock: Arc<dyn WorkspaceClock>, 157 ) -> Result<Self, WorkspaceError> { 158 // Taking the sole prepared grant is irreversible, even if this observer 159 // disappears. Retained selectors/proof permit reopening, never cloning authority. 160 let record = { 161 enrollment 162 .record 163 .lock() 164 .map_err(|_| WorkspaceError::Unavailable)? 165 .take() 166 .ok_or(WorkspaceError::RecoveryRequired)? 167 }; 168 let binding = record.authenticate(&enrollment.input, &enrollment.proof, clock.now()?)?; 169 let worker = super::worker::Handle::launch_stock( 170 path.to_path_buf(), 171 enrollment.input.clone(), 172 Some((record, enrollment.transaction, binding.expires_at())), 173 crypto, 174 clock, 175 ) 176 .await?; 177 Ok(Self { 178 worker: Arc::new(worker), 179 }) 180 } 181 pub async fn open_seller_stock( 182 path: &Path, 183 expected: AttachmentInput, 184 crypto: WorkspaceCrypto, 185 clock: Arc<dyn WorkspaceClock>, 186 ) -> Result<Self, WorkspaceError> { 187 let worker = 188 super::worker::Handle::launch_stock(path.to_path_buf(), expected, None, crypto, clock) 189 .await?; 190 Ok(Self { 191 worker: Arc::new(worker), 192 }) 193 } 194 /// Query after an interrupted creation using the retained original selection. 195 pub async fn stock_authority( 196 &self, 197 input: AttachmentInput, 198 proof: &AttachmentProof, 199 ) -> Result<StockAuthorityReceipt, WorkspaceError> { 200 let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; 201 self.worker.stock_authority(input, proof).await 202 } 203 } 204 #[derive(Clone)] 205 struct Authority { 206 catalog: i64, 207 input: AttachmentInput, 208 transaction: TransactionId, 209 revocation: Sequence, 210 inventory: Option<InventoryCheckpoint>, 211 authorization: Option<StockAuthorizationRef>, 212 sources: Option<SourceCheckpoint>, 213 public_sources: Option<PublicSourceCheckpoint>, 214 } 215 #[derive(Clone, Copy, Serialize, Deserialize)] 216 #[serde(deny_unknown_fields)] 217 struct PublicSourceCheckpoint { 218 revision: Sequence, 219 events: Sequence, 220 heads: Sequence, 221 parts: Sequence, 222 #[serde(deserialize_with = "required_nullable")] 223 head: Option<radroots_domain::CheckpointDigest>, 224 } 225 impl PublicSourceCheckpoint { 226 fn validate(self) -> Result<(), WorkspaceError> { 227 if self.revision != self.events 228 || (self.revision.get() == 0) != self.head.is_none() 229 || (self.revision.get() == 0) != (self.heads.get() == 0) 230 || self.heads.get() > self.events.get() 231 || self.parts.get() < self.events.get() 232 || self.parts.get() > self.events.get().saturating_mul(4) 233 { 234 return Err(WorkspaceError::RecoveryRequired); 235 } 236 Ok(()) 237 } 238 } 239 #[derive(Clone, Copy, Serialize, Deserialize)] 240 #[serde(deny_unknown_fields)] 241 struct SourceCheckpoint { 242 revision: Sequence, 243 records: Sequence, 244 parts: Sequence, 245 #[serde(deserialize_with = "required_nullable")] 246 head: Option<radroots_domain::CheckpointDigest>, 247 } 248 #[derive(Clone, Copy, Serialize, Deserialize)] 249 #[serde(deny_unknown_fields)] 250 struct InventoryCheckpointLegacy { 251 revision: Sequence, 252 pools: Sequence, 253 movements: Sequence, 254 #[serde(deserialize_with = "required_nullable")] 255 head: Option<radroots_domain::CheckpointDigest>, 256 } 257 #[derive(Clone, Copy)] 258 struct InventoryCheckpoint { 259 revision: Sequence, 260 pools: Sequence, 261 movements: Sequence, 262 head: Option<radroots_domain::CheckpointDigest>, 263 mappings: Option<Sequence>, 264 orders: Option<Sequence>, 265 } 266 #[derive(Clone, Copy, Serialize, Deserialize)] 267 #[serde(deny_unknown_fields)] 268 struct InventoryCheckpointCurrent { 269 revision: Sequence, 270 pools: Sequence, 271 movements: Sequence, 272 mappings: Sequence, 273 #[serde(deserialize_with = "required_nullable")] 274 head: Option<radroots_domain::CheckpointDigest>, 275 } 276 #[derive(Clone, Copy, Serialize, Deserialize)] 277 #[serde(deny_unknown_fields)] 278 struct InventoryCheckpointUnified { 279 revision: Sequence, 280 pools: Sequence, 281 movements: Sequence, 282 mappings: Sequence, 283 orders: Sequence, 284 #[serde(deserialize_with = "required_nullable")] 285 head: Option<radroots_domain::CheckpointDigest>, 286 } 287 impl From<InventoryCheckpointLegacy> for InventoryCheckpoint { 288 fn from(value: InventoryCheckpointLegacy) -> Self { 289 Self { 290 revision: value.revision, 291 pools: value.pools, 292 movements: value.movements, 293 head: value.head, 294 mappings: None, 295 orders: None, 296 } 297 } 298 } 299 impl From<InventoryCheckpointCurrent> for InventoryCheckpoint { 300 fn from(value: InventoryCheckpointCurrent) -> Self { 301 Self { 302 revision: value.revision, 303 pools: value.pools, 304 movements: value.movements, 305 head: value.head, 306 mappings: Some(value.mappings), 307 orders: None, 308 } 309 } 310 } 311 impl From<InventoryCheckpointUnified> for InventoryCheckpoint { 312 fn from(value: InventoryCheckpointUnified) -> Self { 313 Self { 314 revision: value.revision, 315 pools: value.pools, 316 movements: value.movements, 317 head: value.head, 318 mappings: Some(value.mappings), 319 orders: Some(value.orders), 320 } 321 } 322 } 323 impl InventoryCheckpoint { 324 fn legacy(self) -> Result<InventoryCheckpointLegacy, WorkspaceError> { 325 if self.mappings.is_some() { 326 return Err(WorkspaceError::RecoveryRequired); 327 } 328 Ok(InventoryCheckpointLegacy { 329 revision: self.revision, 330 pools: self.pools, 331 movements: self.movements, 332 head: self.head, 333 }) 334 } 335 fn current(self) -> Result<InventoryCheckpointCurrent, WorkspaceError> { 336 Ok(InventoryCheckpointCurrent { 337 revision: self.revision, 338 pools: self.pools, 339 movements: self.movements, 340 head: self.head, 341 mappings: self.mappings.ok_or(WorkspaceError::RecoveryRequired)?, 342 }) 343 } 344 fn unified(self) -> Result<InventoryCheckpointUnified, WorkspaceError> { 345 Ok(InventoryCheckpointUnified { 346 revision: self.revision, 347 pools: self.pools, 348 movements: self.movements, 349 head: self.head, 350 mappings: self.mappings.ok_or(WorkspaceError::RecoveryRequired)?, 351 orders: self.orders.ok_or(WorkspaceError::RecoveryRequired)?, 352 }) 353 } 354 } 355 fn required_nullable<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( 356 d: D, 357 ) -> Result<Option<T>, D::Error> { 358 Option::deserialize(d) 359 } 360 fn optional_present<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( 361 d: D, 362 ) -> Result<Option<T>, D::Error> { 363 T::deserialize(d).map(Some) 364 } 365 #[derive(Serialize, Deserialize)] 366 #[serde(deny_unknown_fields)] 367 struct AuthorityV1 { 368 version: u8, 369 input: AttachmentInput, 370 transaction: TransactionId, 371 revocation: Sequence, 372 } 373 #[derive(Serialize, Deserialize)] 374 #[serde(deny_unknown_fields)] 375 struct InventoryAuthorityWire { 376 version: u8, 377 input: AttachmentInput, 378 transaction: TransactionId, 379 revocation: Sequence, 380 inventory: InventoryCheckpointLegacy, 381 } 382 #[derive(Serialize, Deserialize)] 383 #[serde(deny_unknown_fields)] 384 struct AuthorityV4 { 385 version: u8, 386 namespace: SellerAuthoritySelection, 387 administrator: GrantId, 388 transaction: TransactionId, 389 revocation: Sequence, 390 inventory: InventoryCheckpointLegacy, 391 authorization: StockAuthorizationRef, 392 } 393 #[derive(Serialize, Deserialize)] 394 #[serde(deny_unknown_fields)] 395 struct AuthorityV5 { 396 version: u8, 397 namespace: SellerAuthoritySelection, 398 administrator: GrantId, 399 transaction: TransactionId, 400 revocation: Sequence, 401 #[serde(deserialize_with = "object")] 402 inventory: InventoryCheckpointCurrent, 403 authorization: StockAuthorizationRef, 404 } 405 #[derive(Serialize, Deserialize)] 406 #[serde(deny_unknown_fields)] 407 struct AuthorityV6 { 408 version: u8, 409 namespace: SellerAuthoritySelection, 410 administrator: GrantId, 411 transaction: TransactionId, 412 revocation: Sequence, 413 #[serde(deserialize_with = "object")] 414 inventory: InventoryCheckpointCurrent, 415 #[serde(deserialize_with = "object")] 416 sources: SourceCheckpoint, 417 authorization: StockAuthorizationRef, 418 } 419 #[derive(Serialize, Deserialize)] 420 #[serde(deny_unknown_fields)] 421 struct AuthorityV7 { 422 version: u8, 423 #[serde(deserialize_with = "object")] 424 namespace: SellerAuthoritySelection, 425 administrator: GrantId, 426 transaction: TransactionId, 427 revocation: Sequence, 428 #[serde(deserialize_with = "object")] 429 inventory: InventoryCheckpointUnified, 430 #[serde(deserialize_with = "object")] 431 sources: SourceCheckpoint, 432 authorization: StockAuthorizationRef, 433 } 434 #[derive(Serialize, Deserialize)] 435 #[serde(deny_unknown_fields)] 436 struct AuthorityV8 { 437 version: u8, 438 #[serde(deserialize_with = "object")] 439 namespace: SellerAuthoritySelection, 440 administrator: GrantId, 441 transaction: TransactionId, 442 revocation: Sequence, 443 #[serde(deserialize_with = "object")] 444 inventory: InventoryCheckpointUnified, 445 #[serde(deserialize_with = "object")] 446 sources: SourceCheckpoint, 447 #[serde(deserialize_with = "object")] 448 public_sources: PublicSourceCheckpoint, 449 authorization: StockAuthorizationRef, 450 } 451 impl Authority { 452 fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> { 453 if !matches!(self.catalog, 8..=20) && self.public_sources.is_some() { 454 return Err(WorkspaceError::RecoveryRequired); 455 } 456 if matches!(self.catalog, 8..=20) { 457 let public_sources = self 458 .public_sources 459 .ok_or(WorkspaceError::RecoveryRequired)?; 460 public_sources.validate()?; 461 let bytes = zeroize::Zeroizing::new( 462 serde_json::to_vec(&AuthorityV8 { 463 version: self.catalog as u8, 464 namespace: SellerAuthoritySelection::from_attachment(&self.input), 465 administrator: self.input.grant_id(), 466 transaction: self.transaction, 467 revocation: self.revocation, 468 inventory: self 469 .inventory 470 .ok_or(WorkspaceError::RecoveryRequired)? 471 .unified()?, 472 sources: self.sources.ok_or(WorkspaceError::RecoveryRequired)?, 473 public_sources, 474 authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?, 475 }) 476 .map_err(|_| WorkspaceError::StorageFailure)?, 477 ); 478 if bytes.len() > 16 * 1024 { 479 return Err(WorkspaceError::Capacity); 480 } 481 return Ok(bytes); 482 } 483 if self.catalog == 7 { 484 let bytes = zeroize::Zeroizing::new( 485 serde_json::to_vec(&AuthorityV7 { 486 version: 7, 487 namespace: SellerAuthoritySelection::from_attachment(&self.input), 488 administrator: self.input.grant_id(), 489 transaction: self.transaction, 490 revocation: self.revocation, 491 inventory: self 492 .inventory 493 .ok_or(WorkspaceError::RecoveryRequired)? 494 .unified()?, 495 sources: self.sources.ok_or(WorkspaceError::RecoveryRequired)?, 496 authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?, 497 }) 498 .map_err(|_| WorkspaceError::StorageFailure)?, 499 ); 500 if bytes.len() > 16 * 1024 { 501 return Err(WorkspaceError::Capacity); 502 } 503 return Ok(bytes); 504 } 505 if self.catalog == 6 { 506 let bytes = serde_json::to_vec(&AuthorityV6 { 507 version: 6, 508 namespace: SellerAuthoritySelection::from_attachment(&self.input), 509 administrator: self.input.grant_id(), 510 transaction: self.transaction, 511 revocation: self.revocation, 512 inventory: self 513 .inventory 514 .ok_or(WorkspaceError::RecoveryRequired)? 515 .current()?, 516 sources: self.sources.ok_or(WorkspaceError::RecoveryRequired)?, 517 authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?, 518 }) 519 .map_err(|_| WorkspaceError::StorageFailure)?; 520 if bytes.len() > 16 * 1024 { 521 return Err(WorkspaceError::Capacity); 522 } 523 return Ok(zeroize::Zeroizing::new(bytes)); 524 } 525 if self.catalog == 5 { 526 let bytes = serde_json::to_vec(&AuthorityV5 { 527 version: 5, 528 namespace: SellerAuthoritySelection::from_attachment(&self.input), 529 administrator: self.input.grant_id(), 530 transaction: self.transaction, 531 revocation: self.revocation, 532 inventory: self 533 .inventory 534 .ok_or(WorkspaceError::RecoveryRequired)? 535 .current()?, 536 authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?, 537 }) 538 .map_err(|_| WorkspaceError::StorageFailure)?; 539 if bytes.len() > 16 * 1024 { 540 return Err(WorkspaceError::Capacity); 541 } 542 return Ok(zeroize::Zeroizing::new(bytes)); 543 } 544 if self.catalog == 4 { 545 let bytes = serde_json::to_vec(&AuthorityV4 { 546 version: 4, 547 namespace: SellerAuthoritySelection::from_attachment(&self.input), 548 administrator: self.input.grant_id(), 549 transaction: self.transaction, 550 revocation: self.revocation, 551 inventory: self 552 .inventory 553 .ok_or(WorkspaceError::RecoveryRequired)? 554 .legacy()?, 555 authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?, 556 }) 557 .map_err(|_| WorkspaceError::StorageFailure)?; 558 if bytes.len() > 16 * 1024 { 559 return Err(WorkspaceError::Capacity); 560 } 561 return Ok(zeroize::Zeroizing::new(bytes)); 562 } 563 let bytes = match self.inventory { 564 None => serde_json::to_vec(&AuthorityV1 { 565 version: 1, 566 input: self.input.clone(), 567 transaction: self.transaction, 568 revocation: self.revocation, 569 }), 570 Some(inventory) => serde_json::to_vec(&InventoryAuthorityWire { 571 version: self.catalog as u8, 572 input: self.input.clone(), 573 transaction: self.transaction, 574 revocation: self.revocation, 575 inventory: inventory.legacy()?, 576 }), 577 } 578 .map_err(|_| WorkspaceError::StorageFailure)?; 579 Ok(zeroize::Zeroizing::new(bytes)) 580 } 581 fn decode(bytes: &[u8], catalog: i64) -> Result<Self, WorkspaceError> { 582 let value = match catalog { 583 1 => { 584 let v: AuthorityV1 = closed_record(bytes)?; 585 if v.version != 1 { 586 return Err(WorkspaceError::RecoveryRequired); 587 } 588 Self { 589 catalog, 590 input: v.input, 591 transaction: v.transaction, 592 revocation: v.revocation, 593 inventory: None, 594 authorization: None, 595 sources: None, 596 public_sources: None, 597 } 598 } 599 2 | 3 => { 600 let v: InventoryAuthorityWire = closed_record(bytes)?; 601 if i64::from(v.version) != catalog 602 || (v.inventory.revision.get() == 0) != v.inventory.head.is_none() 603 { 604 return Err(WorkspaceError::RecoveryRequired); 605 } 606 Self { 607 catalog, 608 input: v.input, 609 transaction: v.transaction, 610 revocation: v.revocation, 611 inventory: Some(v.inventory.into()), 612 authorization: None, 613 sources: None, 614 public_sources: None, 615 } 616 } 617 4 => { 618 let v: AuthorityV4 = closed_record(bytes)?; 619 if v.version != 4 620 || v.authorization.generation() != v.revocation 621 || (v.inventory.revision.get() == 0) != v.inventory.head.is_none() 622 { 623 return Err(WorkspaceError::RecoveryRequired); 624 } 625 Self { 626 catalog, 627 input: v.namespace.attachment(v.administrator)?, 628 transaction: v.transaction, 629 revocation: v.revocation, 630 inventory: Some(v.inventory.into()), 631 authorization: Some(v.authorization), 632 sources: None, 633 public_sources: None, 634 } 635 } 636 5 => { 637 let v: AuthorityV5 = closed_record(bytes)?; 638 if v.version != 5 639 || v.authorization.generation() != v.revocation 640 || (v.inventory.revision.get() == 0) != v.inventory.head.is_none() 641 { 642 return Err(WorkspaceError::RecoveryRequired); 643 } 644 Self { 645 catalog, 646 input: v.namespace.attachment(v.administrator)?, 647 transaction: v.transaction, 648 revocation: v.revocation, 649 inventory: Some(v.inventory.into()), 650 authorization: Some(v.authorization), 651 sources: None, 652 public_sources: None, 653 } 654 } 655 6 => { 656 let value: AuthorityV6 = closed_record(bytes)?; 657 if value.version != 6 658 || value.authorization.generation() != value.revocation 659 || (value.inventory.revision.get() == 0) != value.inventory.head.is_none() 660 || (value.sources.revision.get() == 0) != value.sources.head.is_none() 661 || (value.sources.revision.get() == 0) != (value.sources.parts.get() == 0) 662 || value.sources.records.get() > value.sources.revision.get() 663 || value.sources.parts.get() / 3 < value.sources.revision.get() 664 || value.sources.parts.get() > value.sources.revision.get().saturating_mul(12) 665 { 666 return Err(WorkspaceError::RecoveryRequired); 667 } 668 Self { 669 catalog, 670 input: value.namespace.attachment(value.administrator)?, 671 transaction: value.transaction, 672 revocation: value.revocation, 673 inventory: Some(value.inventory.into()), 674 authorization: Some(value.authorization), 675 sources: Some(value.sources), 676 public_sources: None, 677 } 678 } 679 7 => { 680 let value: AuthorityV7 = closed_record(bytes)?; 681 if value.version != 7 682 || value.authorization.generation() != value.revocation 683 || (value.inventory.revision.get() == 0) != value.inventory.head.is_none() 684 || value.inventory.orders.get() > value.inventory.revision.get() 685 || value.inventory.pools.get() > value.inventory.revision.get() 686 || value.inventory.mappings.get() > value.inventory.revision.get() 687 || value.inventory.movements.get() 688 > value.inventory.revision.get().saturating_mul(64) 689 || (value.sources.revision.get() == 0) != value.sources.head.is_none() 690 || (value.sources.revision.get() == 0) != (value.sources.parts.get() == 0) 691 || value.sources.records.get() > value.sources.revision.get() 692 || value.sources.parts.get() / 3 < value.sources.revision.get() 693 || value.sources.parts.get() > value.sources.revision.get().saturating_mul(12) 694 { 695 return Err(WorkspaceError::RecoveryRequired); 696 } 697 Self { 698 catalog, 699 input: value.namespace.attachment(value.administrator)?, 700 transaction: value.transaction, 701 revocation: value.revocation, 702 inventory: Some(value.inventory.into()), 703 authorization: Some(value.authorization), 704 sources: Some(value.sources), 705 public_sources: None, 706 } 707 } 708 8..=20 => { 709 let value: AuthorityV8 = closed_record(bytes)?; 710 value.public_sources.validate()?; 711 if i64::from(value.version) != catalog 712 || value.authorization.generation() != value.revocation 713 || (value.inventory.revision.get() == 0) != value.inventory.head.is_none() 714 || value.inventory.orders.get() > value.inventory.revision.get() 715 || value.inventory.pools.get() > value.inventory.revision.get() 716 || value.inventory.mappings.get() > value.inventory.revision.get() 717 || value.inventory.movements.get() 718 > value.inventory.revision.get().saturating_mul(64) 719 || (value.sources.revision.get() == 0) != value.sources.head.is_none() 720 || (value.sources.revision.get() == 0) != (value.sources.parts.get() == 0) 721 || value.sources.records.get() > value.sources.revision.get() 722 || value.sources.parts.get() / 3 < value.sources.revision.get() 723 || value.sources.parts.get() > value.sources.revision.get().saturating_mul(12) 724 { 725 return Err(WorkspaceError::RecoveryRequired); 726 } 727 Self { 728 catalog, 729 input: value.namespace.attachment(value.administrator)?, 730 transaction: value.transaction, 731 revocation: value.revocation, 732 inventory: Some(value.inventory.into()), 733 authorization: Some(value.authorization), 734 sources: Some(value.sources), 735 public_sources: Some(value.public_sources), 736 } 737 } 738 _ => return Err(WorkspaceError::RecoveryRequired), 739 }; 740 if value.revocation.get() == 0 { 741 return Err(WorkspaceError::RecoveryRequired); 742 } 743 Ok(value) 744 } 745 fn version(&self) -> i64 { 746 self.catalog 747 } 748 } 749 pub(super) struct Initial { 750 pub grant: GrantRecord, 751 pub transaction: TransactionId, 752 pub expires_at: radroots_domain::UnixSeconds, 753 pub clock: Arc<dyn WorkspaceClock>, 754 } 755 pub(in crate::workspace) mod envelope; 756 pub(super) mod inventory; 757 mod schema; 758 pub(super) async fn initialize( 759 connection: &mut SqliteConnection, 760 namespace: &Namespace, 761 input: &AttachmentInput, 762 initial: Option<Initial>, 763 crypto: &WorkspaceCrypto, 764 ) -> Result<(), WorkspaceError> { 765 namespace.validate()?; 766 if let Some(initial) = initial { 767 let mut authority = Authority { 768 public_sources: Some(PublicSourceCheckpoint { 769 revision: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 770 events: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 771 heads: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 772 parts: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 773 head: None, 774 }), 775 sources: Some(SourceCheckpoint { 776 revision: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 777 records: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 778 parts: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 779 head: None, 780 }), 781 catalog: schema::CURRENT, 782 authorization: None, 783 input: input.clone(), 784 transaction: initial.transaction, 785 revocation: Sequence::new(1).map_err(|_| WorkspaceError::InvalidInput)?, 786 inventory: Some(InventoryCheckpoint { 787 orders: if schema::CURRENT >= 7 { 788 Some(Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?) 789 } else { 790 None 791 }, 792 mappings: Some(Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?), 793 revision: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 794 head: None, 795 pools: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 796 movements: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, 797 }), 798 }; 799 let initial_record = StockGrantRecord::from_enrollment(initial.grant)?; 800 let grant = crypto 801 .seal_stock_record( 802 input, 803 "grant", 804 input.grant_id().as_bytes(), 805 &initial_record.encode()?, 806 ) 807 .await?; 808 authority.authorization = Some(grants::single_state(input.grant_id(), &grant)?); 809 let clear = authority.encode()?; 810 let root = crypto 811 .seal_stock_root(input, authority.version(), &clear) 812 .await?; 813 let now = initial.clock.now()?; 814 if now.get() == 0 { 815 return Err(WorkspaceError::Unavailable); 816 } 817 if now >= initial.expires_at { 818 return Err(WorkspaceError::GrantExpired); 819 } 820 let mut tx = connection 821 .begin_with("BEGIN IMMEDIATE") 822 .await 823 .map_err(|_| WorkspaceError::StorageFailure)?; 824 let changed: Result<(), WorkspaceError> = async { 825 namespace.validate()?; 826 let now = initial.clock.now()?; 827 if now.get() == 0 { 828 return Err(WorkspaceError::Unavailable); 829 } 830 if now >= initial.expires_at { 831 return Err(WorkspaceError::GrantExpired); 832 } 833 for (_, _, _, sql) in schema::objects(schema::CURRENT)? { 834 sqlx::raw_sql(sql) 835 .execute(&mut *tx) 836 .await 837 .map_err(|_| WorkspaceError::StorageFailure)?; 838 } 839 sqlx::query("PRAGMA user_version=20") 840 .execute(&mut *tx) 841 .await 842 .map_err(|_| WorkspaceError::StorageFailure)?; 843 sqlx::query("INSERT INTO stock_authority(singleton,protected) VALUES(1,?)") 844 .bind(root) 845 .execute(&mut *tx) 846 .await 847 .map_err(|_| WorkspaceError::StorageFailure)?; 848 sqlx::query("INSERT INTO stock_grants(grant_id,protected) VALUES(?,?)") 849 .bind(input.grant_id().as_bytes().as_slice()) 850 .bind(grant) 851 .execute(&mut *tx) 852 .await 853 .map_err(|_| WorkspaceError::StorageFailure)?; 854 Ok(()) 855 } 856 .await; 857 if let Err(error) = changed { 858 tx.rollback() 859 .await 860 .map_err(|_| WorkspaceError::CommitUnknown)?; 861 return Err(error); 862 } 863 tx.commit() 864 .await 865 .map_err(|_| WorkspaceError::CommitUnknown)?; 866 } 867 schema::admit(connection).await?; 868 schema::integrity(connection).await?; 869 read(connection, input, crypto).await?; 870 namespace.validate() 871 } 872 /// Retained credential authentication only; no new command permission. 873 pub(super) struct CaptureAuthorization(StockRecord); 874 impl CaptureAuthorization { 875 pub(super) fn authenticate( 876 &self, 877 input: &AttachmentInput, 878 proof: &AttachmentProof, 879 ) -> Result<(), WorkspaceError> { 880 self.0.authenticate_retained_capture(input, proof) 881 } 882 } 883 pub(super) async fn capture_authorization( 884 connection: &mut SqliteConnection, 885 input: &AttachmentInput, 886 crypto: &WorkspaceCrypto, 887 proof: &AttachmentProof, 888 ) -> Result<CaptureAuthorization, WorkspaceError> { 889 let (_, record, _, _) = read(connection, input, crypto).await?; 890 record.authenticate_retained_capture(input, proof)?; 891 Ok(CaptureAuthorization(record)) 892 } 893 async fn read( 894 connection: &mut SqliteConnection, 895 input: &AttachmentInput, 896 crypto: &WorkspaceCrypto, 897 ) -> Result<(Authority, StockRecord, Vec<u8>, Vec<u8>), WorkspaceError> { 898 // Bound in SQL before materializing attacker-controlled protected payloads. 899 let root: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_authority WHERE singleton=1 AND length(protected) BETWEEN 1 AND 262144").fetch_optional(&mut *connection).await.map_err(|_| WorkspaceError::RecoveryRequired)?.ok_or(WorkspaceError::RecoveryRequired)?; 900 let grant: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_grants WHERE grant_id=? AND length(protected) BETWEEN 1 AND 262144").bind(input.grant_id().as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_| WorkspaceError::RecoveryRequired)?.ok_or(WorkspaceError::WrongNamespace)?; 901 let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") 902 .fetch_one(&mut *connection) 903 .await 904 .map_err(|_| WorkspaceError::RecoveryRequired)?; 905 let clear = crypto.open_stock_root(input, catalog, &root).await?; 906 let authority = clear.expose_secret(|bytes| Authority::decode(bytes, catalog))?; 907 if (if catalog >= 4 { 908 !SellerAuthoritySelection::from_attachment(&authority.input).matches_attachment(input) 909 } else { 910 authority.input != *input 911 }) || authority.revocation.get() == 0 912 { 913 return Err(WorkspaceError::WrongNamespace); 914 } 915 let record = if catalog >= 4 { 916 grants::check_state( 917 connection, 918 authority 919 .authorization 920 .ok_or(WorkspaceError::RecoveryRequired)?, 921 ) 922 .await?; 923 let clear = crypto 924 .open_stock_record(input, "grant", input.grant_id().as_bytes(), &grant) 925 .await?; 926 let record = clear.expose_secret(StockGrantRecord::decode)?; 927 if !record.belongs_to(&SellerAuthoritySelection::from_attachment(input))? 928 || record.administrator() != (input.grant_id() == authority.input.grant_id()) 929 { 930 return Err(WorkspaceError::RecoveryRequired); 931 } 932 StockRecord::Scoped(record) 933 } else { 934 let clear = crypto.open_stock(input, false, &grant).await?; 935 let record = clear.expose_secret(GrantRecord::decode)?; 936 if record.scope() != WorkspaceScope::SellerStockOwner { 937 return Err(WorkspaceError::RecoveryRequired); 938 } 939 StockRecord::Legacy(record) 940 }; 941 if let Some(checkpoint) = authority.inventory { 942 inventory::check_head(connection, checkpoint).await?; 943 } 944 if let Some(checkpoint) = authority.sources { 945 check_source_counts(connection, checkpoint).await?; 946 } 947 if let Some(checkpoint) = authority.public_sources { 948 public_source::counts(connection, checkpoint).await?; 949 } 950 Ok((authority, record, root, grant)) 951 } 952 pub(super) async fn authenticate( 953 connection: &mut SqliteConnection, 954 namespace: &Namespace, 955 expected: &AttachmentInput, 956 crypto: &WorkspaceCrypto, 957 clock: &dyn WorkspaceClock, 958 selected: &AttachmentInput, 959 proof: &AttachmentProof, 960 ) -> Result<(StockAuthorityReceipt, WorkspaceBinding), WorkspaceError> { 961 namespace.validate()?; 962 if !SellerAuthoritySelection::from_attachment(expected).matches_attachment(selected) { 963 return Err(WorkspaceError::WrongNamespace); 964 } 965 let (authority, record, root, grant) = read(connection, selected, crypto).await?; 966 record.authenticate(selected, proof, clock.now()?)?; 967 let mut tx = connection 968 .begin_with("BEGIN IMMEDIATE") 969 .await 970 .map_err(|_| WorkspaceError::StorageFailure)?; 971 let checked = async { 972 namespace.validate()?; 973 unchanged(&mut tx, selected, authority.version(), &root, &grant).await?; 974 if let Some(state) = authority.authorization { 975 grants::check_state(&mut tx, state).await?; 976 } 977 record.authenticate(selected, proof, clock.now()?) 978 } 979 .await; 980 tx.rollback() 981 .await 982 .map_err(|_| WorkspaceError::CommitUnknown)?; 983 let binding = checked?; 984 let binding = if let Some(state) = authority.authorization { 985 binding.with_stock_authorization(state)? 986 } else { 987 binding 988 }; 989 if binding.scope() != WorkspaceScope::SellerStockOwner { 990 return Err(WorkspaceError::RecoveryRequired); 991 } 992 namespace.validate()?; 993 Ok(( 994 StockAuthorityReceipt { 995 public_sources:authority.public_sources.map(|value|radroots_storage::workspace::seller_stock::StockListingCheckpointRef::from_host_metadata(expected.authority(),value.revision,value.head).map(|state|state.with_optional_authorization(authority.authorization))).transpose()?, 996 sources:authority.sources.map(|value|radroots_storage::workspace::seller_stock::StockSourceCheckpointRef::from_host_metadata(expected.authority(),value.revision,value.head).map(|state|state.with_optional_authorization(authority.authorization))).transpose()?, 997 input: authority.input, 998 transaction: authority.transaction, 999 revocation: authority.revocation, 1000 inventory: authority 1001 .inventory 1002 .map(|v| { 1003 radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( 1004 expected.authority(), 1005 v.revision, 1006 v.head, 1007 ) 1008 .map(|checkpoint| { 1009 if let Some(state) = authority.authorization { 1010 checkpoint.with_authorization(state) 1011 } else { 1012 checkpoint 1013 } 1014 }) 1015 }) 1016 .transpose()?, 1017 }, 1018 binding, 1019 )) 1020 } 1021 pub(super) async fn revoke( 1022 connection: &mut SqliteConnection, 1023 namespace: &Namespace, 1024 expected: &AttachmentInput, 1025 crypto: &WorkspaceCrypto, 1026 clock: &dyn WorkspaceClock, 1027 selected: &AttachmentInput, 1028 proof: &AttachmentProof, 1029 ) -> Result<(), WorkspaceError> { 1030 namespace.validate()?; 1031 if !SellerAuthoritySelection::from_attachment(expected).matches_attachment(selected) { 1032 return Err(WorkspaceError::WrongNamespace); 1033 } 1034 let (mut authority, mut record, old_root, old_grant) = 1035 read(connection, selected, crypto).await?; 1036 if authority.catalog >= 4 { 1037 return Err(WorkspaceError::Unauthorized); 1038 } 1039 let expiry = record 1040 .authenticate(selected, proof, clock.now()?)? 1041 .expires_at(); 1042 record.revoke()?; 1043 authority.revocation = Sequence::new( 1044 authority 1045 .revocation 1046 .get() 1047 .checked_add(1) 1048 .ok_or(WorkspaceError::Capacity)?, 1049 ) 1050 .map_err(|_| WorkspaceError::Capacity)?; 1051 let clear = authority.encode()?; 1052 let root = crypto 1053 .seal_stock_root(expected, authority.version(), &clear) 1054 .await?; 1055 let grant = crypto 1056 .seal_stock(expected, false, &record.encode()?) 1057 .await?; 1058 namespace.validate()?; 1059 let mut tx = connection 1060 .begin_with("BEGIN IMMEDIATE") 1061 .await 1062 .map_err(|_| WorkspaceError::StorageFailure)?; 1063 let changed: Result<(), WorkspaceError> = async { 1064 unchanged( 1065 &mut tx, 1066 expected, 1067 authority.version(), 1068 &old_root, 1069 &old_grant, 1070 ) 1071 .await?; 1072 // Current clock and both exact protected snapshots fence the write after provider IO. 1073 record.authenticate_retained_capture(selected, proof)?; 1074 let now = clock.now()?; 1075 if now.get() == 0 { 1076 return Err(WorkspaceError::Unavailable); 1077 } 1078 if now >= expiry { 1079 return Err(WorkspaceError::GrantExpired); 1080 } 1081 let a = 1082 sqlx::query("UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?") 1083 .bind(root) 1084 .bind(old_root) 1085 .execute(&mut *tx) 1086 .await 1087 .map_err(|_| WorkspaceError::StorageFailure)?; 1088 let g = sqlx::query("UPDATE stock_grants SET protected=? WHERE grant_id=? AND protected=?") 1089 .bind(grant) 1090 .bind(expected.grant_id().as_bytes().as_slice()) 1091 .bind(old_grant) 1092 .execute(&mut *tx) 1093 .await 1094 .map_err(|_| WorkspaceError::StorageFailure)?; 1095 if a.rows_affected() != 1 || g.rows_affected() != 1 { 1096 return Err(WorkspaceError::RecoveryRequired); 1097 } 1098 namespace.validate()?; 1099 Ok(()) 1100 } 1101 .await; 1102 if let Err(error) = changed { 1103 tx.rollback() 1104 .await 1105 .map_err(|_| WorkspaceError::CommitUnknown)?; 1106 return Err(error); 1107 } 1108 tx.commit().await.map_err(|_| WorkspaceError::CommitUnknown) 1109 } 1110 1111 async fn unchanged( 1112 connection: &mut SqliteConnection, 1113 input: &AttachmentInput, 1114 catalog: i64, 1115 root: &[u8], 1116 grant: &[u8], 1117 ) -> Result<(), WorkspaceError> { 1118 let current: i64 = sqlx::query_scalar("PRAGMA user_version") 1119 .fetch_one(&mut *connection) 1120 .await 1121 .map_err(|_| WorkspaceError::RecoveryRequired)?; 1122 if current != catalog { 1123 return Err(WorkspaceError::RecoveryRequired); 1124 } 1125 let matched: i64 = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM stock_authority WHERE singleton=1 AND protected=?) AND EXISTS(SELECT 1 FROM stock_grants WHERE grant_id=? AND protected=?)") 1126 .bind(root).bind(input.grant_id().as_bytes().as_slice()).bind(grant).fetch_one(connection).await.map_err(|_| WorkspaceError::StorageFailure)?; 1127 if matched != 1 { 1128 return Err(WorkspaceError::RecoveryRequired); 1129 } 1130 Ok(()) 1131 } 1132 1133 impl radroots_storage::inventory::InventoryStore for NativeWorkspace { 1134 fn reconcile_stock_evidence<'a>( 1135 &'a self, 1136 request: &'a StockEvidenceRequest, 1137 proof: &'a AttachmentProof, 1138 ) -> radroots_transport::BoxFuture< 1139 'a, 1140 Result<StockEvidenceOutcome, radroots_storage::command::OperationError>, 1141 > { 1142 Box::pin(async move { 1143 self.worker 1144 .reconcile_stock_evidence( 1145 request.retained_copy(), 1146 proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?, 1147 ) 1148 .await 1149 }) 1150 } 1151 fn capture_stock_evidence<'a>( 1152 &'a self, 1153 request: &'a StockEvidenceRequest, 1154 proof: &'a AttachmentProof, 1155 ) -> radroots_transport::BoxFuture< 1156 'a, 1157 Result<StockEvidenceOutcome, radroots_storage::command::OperationError>, 1158 > { 1159 Box::pin(async move { 1160 self.worker 1161 .capture_stock_signing_evidence( 1162 request.retained_copy(), 1163 proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?, 1164 ) 1165 .await 1166 }) 1167 } 1168 fn capture_stock_envelope<'a>( 1169 &'a self, 1170 request: radroots_storage::inventory::StockEnvelopeRequest, 1171 proof: AttachmentProof, 1172 candidate: &'a radroots_storage::command::PrivateEnvelopeCandidate, 1173 ) -> radroots_transport::BoxFuture< 1174 'a, 1175 Result< 1176 radroots_storage::inventory::StockEnvelopeOutcome, 1177 radroots_storage::command::OperationError, 1178 >, 1179 > { 1180 Box::pin(async move { 1181 if request.envelope_event_id().is_some() { 1182 return Err(radroots_storage::command::OperationError::InvalidCommand); 1183 } 1184 self.worker 1185 .capture_stock_envelope(request, proof, candidate.retained_copy()) 1186 .await 1187 }) 1188 } 1189 fn stock_envelope( 1190 &self, 1191 request: radroots_storage::inventory::StockEnvelopeRequest, 1192 proof: AttachmentProof, 1193 ) -> radroots_transport::BoxFuture< 1194 '_, 1195 Result< 1196 Option<radroots_storage::inventory::StockEnvelopeSource>, 1197 radroots_storage::command::OperationError, 1198 >, 1199 > { 1200 Box::pin(self.worker.stock_envelope(request, proof)) 1201 } 1202 fn reconcile_stock_envelope<'a>( 1203 &'a self, 1204 request: radroots_storage::inventory::StockEnvelopeRequest, 1205 proof: AttachmentProof, 1206 candidate: &'a radroots_storage::command::PrivateEnvelopeCandidate, 1207 ) -> radroots_transport::BoxFuture< 1208 'a, 1209 Result< 1210 radroots_storage::inventory::StockEnvelopeOutcome, 1211 radroots_storage::command::OperationError, 1212 >, 1213 > { 1214 Box::pin(async move { 1215 if request.envelope_event_id().is_some() { 1216 return Err(radroots_storage::command::OperationError::InvalidCommand); 1217 } 1218 self.worker 1219 .reconcile_stock_envelope(request, proof, candidate.retained_copy()) 1220 .await 1221 }) 1222 } 1223 fn prepare_stock_rewrap( 1224 &self, 1225 request: radroots_storage::inventory::StockRewrapRequest, 1226 proof: AttachmentProof, 1227 ) -> radroots_transport::BoxFuture< 1228 '_, 1229 Result< 1230 radroots_storage::inventory::StockRewrapOutcome, 1231 radroots_storage::command::OperationError, 1232 >, 1233 > { 1234 Box::pin(self.worker.prepare_stock_rewrap(request, proof)) 1235 } 1236 fn stock_rewrap_attempt( 1237 &self, 1238 request: radroots_storage::inventory::StockRewrapRequest, 1239 proof: AttachmentProof, 1240 ) -> radroots_transport::BoxFuture< 1241 '_, 1242 Result< 1243 Option<radroots_storage::inventory::StockRewrapState>, 1244 radroots_storage::command::OperationError, 1245 >, 1246 > { 1247 Box::pin(self.worker.stock_rewrap_attempt(request, proof)) 1248 } 1249 fn reconcile_stock_rewrap_admission( 1250 &self, 1251 request: radroots_storage::inventory::StockRewrapRequest, 1252 proof: AttachmentProof, 1253 ) -> radroots_transport::BoxFuture<'_, Result<(), radroots_storage::command::OperationError>> 1254 { 1255 Box::pin(self.worker.reconcile_stock_rewrap_admission(request, proof)) 1256 } 1257 fn capture_stock_rewrap<'a>( 1258 &'a self, 1259 request: radroots_storage::inventory::StockRewrapRequest, 1260 proof: AttachmentProof, 1261 candidate: &'a radroots_storage::command::PrivateEnvelopeCandidate, 1262 ) -> radroots_transport::BoxFuture< 1263 'a, 1264 Result< 1265 radroots_storage::inventory::StockEnvelopeOutcome, 1266 radroots_storage::command::OperationError, 1267 >, 1268 > { 1269 Box::pin(async move { 1270 if request.source().envelope_event_id().is_none() { 1271 return Err(radroots_storage::command::OperationError::InvalidCommand); 1272 } 1273 self.worker 1274 .capture_stock_rewrap(request, proof, candidate.retained_copy(), false) 1275 .await 1276 }) 1277 } 1278 fn reconcile_stock_rewrap<'a>( 1279 &'a self, 1280 request: radroots_storage::inventory::StockRewrapRequest, 1281 proof: AttachmentProof, 1282 candidate: &'a radroots_storage::command::PrivateEnvelopeCandidate, 1283 ) -> radroots_transport::BoxFuture< 1284 'a, 1285 Result< 1286 radroots_storage::inventory::StockEnvelopeOutcome, 1287 radroots_storage::command::OperationError, 1288 >, 1289 > { 1290 Box::pin(async move { 1291 if request.source().envelope_event_id().is_none() { 1292 return Err(radroots_storage::command::OperationError::InvalidCommand); 1293 } 1294 self.worker 1295 .capture_stock_rewrap(request, proof, candidate.retained_copy(), true) 1296 .await 1297 }) 1298 } 1299 fn stock_rewraps( 1300 &self, 1301 request: radroots_storage::inventory::StockEnvelopeRequest, 1302 after: Option<radroots_domain::Sequence>, 1303 proof: AttachmentProof, 1304 ) -> radroots_transport::BoxFuture< 1305 '_, 1306 Result< 1307 radroots_storage::inventory::StockRewrapPage, 1308 radroots_storage::command::OperationError, 1309 >, 1310 > { 1311 Box::pin(self.worker.stock_rewraps(request, after, proof)) 1312 } 1313 fn prepare_stock_delivery_attempt( 1314 &self, 1315 request: radroots_storage::inventory::StockDeliveryRequest, 1316 proof: AttachmentProof, 1317 ) -> radroots_transport::BoxFuture< 1318 '_, 1319 Result< 1320 radroots_storage::inventory::StockDeliveryAttemptOutcome, 1321 radroots_storage::command::OperationError, 1322 >, 1323 > { 1324 Box::pin(self.worker.prepare_stock_delivery_attempt(request, proof)) 1325 } 1326 fn stock_delivery_attempt( 1327 &self, 1328 source: radroots_storage::inventory::StockEnvelopeRequest, 1329 request_id: radroots_transport::sink::DeliveryRequestId, 1330 proof: AttachmentProof, 1331 ) -> radroots_transport::BoxFuture< 1332 '_, 1333 Result< 1334 Option<radroots_storage::inventory::StockDeliveryAttempt>, 1335 radroots_storage::command::OperationError, 1336 >, 1337 > { 1338 Box::pin( 1339 self.worker 1340 .stock_delivery_attempt(source, request_id, proof), 1341 ) 1342 } 1343 fn stock_delivery_summary( 1344 &self, 1345 source: radroots_storage::inventory::StockEnvelopeRequest, 1346 proof: AttachmentProof, 1347 ) -> radroots_transport::BoxFuture< 1348 '_, 1349 Result< 1350 radroots_storage::inventory::StockDeliverySummary, 1351 radroots_storage::command::OperationError, 1352 >, 1353 > { 1354 Box::pin(self.worker.stock_delivery_summary(source, proof)) 1355 } 1356 fn record_stock_delivery_observation<'a>( 1357 &'a self, 1358 binding: &'a WorkspaceBinding, 1359 proof: &'a AttachmentProof, 1360 observation: &'a radroots_storage::inventory::StockDeliveryObservation, 1361 ) -> radroots_transport::BoxFuture< 1362 'a, 1363 Result< 1364 radroots_storage::inventory::StockDeliveryObservationOutcome, 1365 radroots_storage::command::OperationError, 1366 >, 1367 > { 1368 Box::pin(async move { 1369 self.worker 1370 .record_stock_delivery_observation( 1371 binding.clone(), 1372 proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?, 1373 observation.clone(), 1374 false, 1375 ) 1376 .await 1377 }) 1378 } 1379 fn reconcile_stock_delivery_observation<'a>( 1380 &'a self, 1381 binding: &'a WorkspaceBinding, 1382 proof: &'a AttachmentProof, 1383 observation: &'a radroots_storage::inventory::StockDeliveryObservation, 1384 ) -> radroots_transport::BoxFuture< 1385 'a, 1386 Result< 1387 radroots_storage::inventory::StockDeliveryObservationOutcome, 1388 radroots_storage::command::OperationError, 1389 >, 1390 > { 1391 Box::pin(async move { 1392 self.worker 1393 .record_stock_delivery_observation( 1394 binding.clone(), 1395 proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?, 1396 observation.clone(), 1397 true, 1398 ) 1399 .await 1400 }) 1401 } 1402 fn stock_delivery_observations( 1403 &self, 1404 source: radroots_storage::inventory::StockEnvelopeRequest, 1405 after: Option<Sequence>, 1406 proof: AttachmentProof, 1407 ) -> radroots_transport::BoxFuture< 1408 '_, 1409 Result< 1410 radroots_storage::inventory::StockDeliveryObservationPage, 1411 radroots_storage::command::OperationError, 1412 >, 1413 > { 1414 Box::pin( 1415 self.worker 1416 .stock_delivery_observations(source, after, proof), 1417 ) 1418 } 1419 fn prepare_stock_acceptance( 1420 &self, 1421 request: StockAcceptanceRequest, 1422 proof: AttachmentProof, 1423 ) -> radroots_transport::BoxFuture< 1424 '_, 1425 Result<StockAcceptanceOutcome, radroots_storage::command::OperationError>, 1426 > { 1427 Box::pin(self.worker.prepare_stock_acceptance(request, proof)) 1428 } 1429 fn abort_proven_unissued( 1430 &self, 1431 request: StockAbortRequest, 1432 proof: AttachmentProof, 1433 ) -> radroots_transport::BoxFuture< 1434 '_, 1435 Result<StockAbortOutcome, radroots_storage::command::OperationError>, 1436 > { 1437 Box::pin(self.worker.abort_proven_unissued(request, proof)) 1438 } 1439 fn stock_preparation_abort( 1440 &self, 1441 request: StockAbortRequest, 1442 proof: AttachmentProof, 1443 ) -> radroots_transport::BoxFuture< 1444 '_, 1445 Result<Option<StockAbortReceipt>, radroots_storage::command::OperationError>, 1446 > { 1447 Box::pin(self.worker.stock_preparation_abort(request, proof)) 1448 } 1449 fn option_mapping( 1450 &self, 1451 binding: WorkspaceBinding, 1452 minimum: radroots_storage::inventory::InventoryCheckpointRef, 1453 key: radroots_domain::stock::OptionMappingKey, 1454 proof: AttachmentProof, 1455 ) -> radroots_transport::BoxFuture< 1456 '_, 1457 Result< 1458 Option<radroots_domain::stock::OptionPoolMapping>, 1459 radroots_storage::command::OperationError, 1460 >, 1461 > { 1462 Box::pin(self.worker.option_mapping(binding, minimum, key, proof)) 1463 } 1464 fn execute_inventory( 1465 &self, 1466 request: radroots_storage::inventory::InventoryRequest, 1467 proof: AttachmentProof, 1468 ) -> radroots_transport::BoxFuture< 1469 '_, 1470 Result< 1471 radroots_storage::inventory::InventoryOutcome, 1472 radroots_storage::command::OperationError, 1473 >, 1474 > { 1475 Box::pin(self.worker.execute_inventory(request, proof)) 1476 } 1477 fn inventory_operation( 1478 &self, 1479 binding: WorkspaceBinding, 1480 minimum: radroots_storage::inventory::InventoryCheckpointRef, 1481 operation: radroots_domain::OperationId, 1482 digest: Option<radroots_domain::CommandDigest>, 1483 proof: AttachmentProof, 1484 ) -> radroots_transport::BoxFuture< 1485 '_, 1486 Result< 1487 Option<radroots_storage::inventory::InventoryReceipt>, 1488 radroots_storage::command::OperationError, 1489 >, 1490 > { 1491 Box::pin( 1492 self.worker 1493 .inventory_operation(binding, minimum, operation, digest, proof), 1494 ) 1495 } 1496 fn inspect_stock( 1497 &self, 1498 binding: WorkspaceBinding, 1499 minimum: radroots_storage::inventory::InventoryCheckpointRef, 1500 id: radroots_domain::PoolId, 1501 proof: AttachmentProof, 1502 ) -> radroots_transport::BoxFuture< 1503 '_, 1504 Result< 1505 Option<radroots_storage::inventory::StockSnapshot>, 1506 radroots_storage::command::OperationError, 1507 >, 1508 > { 1509 Box::pin(self.worker.inspect_stock(binding, minimum, id, proof)) 1510 } 1511 fn pool( 1512 &self, 1513 binding: WorkspaceBinding, 1514 minimum: radroots_storage::inventory::InventoryCheckpointRef, 1515 id: radroots_domain::PoolId, 1516 proof: AttachmentProof, 1517 ) -> radroots_transport::BoxFuture< 1518 '_, 1519 Result<Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>, 1520 > { 1521 Box::pin(self.worker.pool(binding, minimum, id, proof)) 1522 } 1523 } 1524 1525 #[cfg(test)] 1526 mod tests; 1527 1528 fn closed_record<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> Result<T, WorkspaceError> { 1529 if bytes.len() > 16 * 1024 1530 || bytes.iter().copied().find(|b| !b.is_ascii_whitespace()) != Some(b'{') 1531 { 1532 return Err(WorkspaceError::RecoveryRequired); 1533 } 1534 serde_json::from_slice(bytes).map_err(|_| WorkspaceError::RecoveryRequired) 1535 } 1536 async fn check_source_counts( 1537 connection: &mut SqliteConnection, 1538 checkpoint: SourceCheckpoint, 1539 ) -> Result<(), WorkspaceError> { 1540 use sqlx::Row; 1541 let row=sqlx::query("SELECT count(*),coalesce(max(revision),0),coalesce(sum(CASE WHEN revision=? AND chain_head=? THEN 1 ELSE 0 END),0) FROM stock_source_evidence").bind(checkpoint.revision.get() as i64).bind(checkpoint.head.map(|id|id.as_bytes().to_vec())).fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; 1542 let count: i64 = row 1543 .try_get(0) 1544 .map_err(|_| WorkspaceError::RecoveryRequired)?; 1545 let maximum: i64 = row 1546 .try_get(1) 1547 .map_err(|_| WorkspaceError::RecoveryRequired)?; 1548 let matched: i64 = row 1549 .try_get(2) 1550 .map_err(|_| WorkspaceError::RecoveryRequired)?; 1551 let records: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_source_records") 1552 .fetch_one(&mut *connection) 1553 .await 1554 .map_err(|_| WorkspaceError::RecoveryRequired)?; 1555 let parts: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_source_parts") 1556 .fetch_one(connection) 1557 .await 1558 .map_err(|_| WorkspaceError::RecoveryRequired)?; 1559 if count != checkpoint.revision.get() as i64 1560 || maximum != count 1561 || matched != i64::from(checkpoint.head.is_some()) 1562 || records != checkpoint.records.get() as i64 1563 || parts != checkpoint.parts.get() as i64 1564 { 1565 return Err(WorkspaceError::RecoveryRequired); 1566 } 1567 Ok(()) 1568 } 1569 fn object<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( 1570 deserializer: D, 1571 ) -> Result<T, D::Error> { 1572 struct Object<T>(std::marker::PhantomData<T>); 1573 impl<'de, T: Deserialize<'de>> serde::de::Visitor<'de> for Object<T> { 1574 type Value = T; 1575 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 1576 f.write_str("a closed object") 1577 } 1578 fn visit_map<A: serde::de::MapAccess<'de>>(self, map: A) -> Result<T, A::Error> { 1579 T::deserialize(serde::de::value::MapAccessDeserializer::new(map)) 1580 } 1581 } 1582 deserializer.deserialize_map(Object(std::marker::PhantomData)) 1583 }