lib

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

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 }