commit e9838a88c90e0b5d88c6f8dbb6a0b2f8b0ba0f04
parent 4a3f71ef59572a9fe6beb10b43ee64a5b2c8a300
Author: triesap <tyson@radroots.org>
Date: Sat, 24 Oct 2026 23:06:19 +0000
storage: enforce scoped inventory grants and retained authority
- Separate namespace selection from authenticated caller grants.
- Commit bounded grants and protected revocation checkpoints atomically.
- Preserve original inventory replay and actor-wide operation identity.
- Verify retained formats and native, Linux and browser boundaries.
Diffstat:
26 files changed, 3260 insertions(+), 127 deletions(-)
diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt
@@ -1372,9 +1372,12 @@ pub radroots_storage::inventory::InventoryOutcome::Unknown(radroots_storage::com
pub struct radroots_storage::inventory::InventoryCheckpointRef
impl radroots_storage::inventory::InventoryCheckpointRef
pub const fn radroots_storage::inventory::InventoryCheckpointRef::authority(self) -> radroots_domain::context::AuthorityRef
+pub const fn radroots_storage::inventory::InventoryCheckpointRef::authorization(self) -> core::option::Option<radroots_storage::workspace::seller_stock::StockAuthorizationRef>
pub fn radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata(radroots_domain::context::AuthorityRef, radroots_domain::context::Sequence, core::option::Option<radroots_domain::identifier::CheckpointDigest>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
pub const fn radroots_storage::inventory::InventoryCheckpointRef::head(self) -> core::option::Option<radroots_domain::identifier::CheckpointDigest>
pub const fn radroots_storage::inventory::InventoryCheckpointRef::revision(self) -> radroots_domain::context::Sequence
+pub const fn radroots_storage::inventory::InventoryCheckpointRef::with_authorization(self, radroots_storage::workspace::seller_stock::StockAuthorizationRef) -> Self
+pub const fn radroots_storage::inventory::InventoryCheckpointRef::with_optional_authorization(self, core::option::Option<radroots_storage::workspace::seller_stock::StockAuthorizationRef>) -> Self
pub struct radroots_storage::inventory::InventoryReceipt
impl radroots_storage::inventory::InventoryReceipt
pub const fn radroots_storage::inventory::InventoryReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt
@@ -1390,6 +1393,8 @@ pub const fn radroots_storage::inventory::InventoryRequest::command(&self) -> &r
pub fn radroots_storage::inventory::InventoryRequest::from_protected_wire(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, &[u8]) -> core::result::Result<Self, radroots_storage::command::OperationError>
pub const fn radroots_storage::inventory::InventoryRequest::minimum_checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef
pub fn radroots_storage::inventory::InventoryRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, impl core::convert::Into<radroots_protocol::command::inventory::CapturedInventoryCommand>) -> core::result::Result<Self, radroots_storage::command::OperationError>
+pub fn radroots_storage::inventory::InventoryRequest::replay_from_protected_wire(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, &[u8]) -> core::result::Result<Self, radroots_storage::command::OperationError>
+pub const fn radroots_storage::inventory::InventoryRequest::replay_only(&self) -> bool
pub fn radroots_storage::inventory::InventoryRequest::retained_copy(&self) -> core::result::Result<Self, radroots_storage::command::OperationError>
impl core::fmt::Debug for radroots_storage::inventory::InventoryRequest
pub fn radroots_storage::inventory::InventoryRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2351,6 +2356,32 @@ pub fn radroots_storage::workspace::local_outbox::LocalOutboxConfig::seller(radr
impl core::fmt::Debug for radroots_storage::workspace::local_outbox::LocalOutboxConfig
pub fn radroots_storage::workspace::local_outbox::LocalOutboxConfig::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
pub mod radroots_storage::workspace::seller_stock
+pub enum radroots_storage::workspace::seller_stock::StockAction
+pub radroots_storage::workspace::seller_stock::StockAction::AddStock
+pub radroots_storage::workspace::seller_stock::StockAction::CreatePool
+pub radroots_storage::workspace::seller_stock::StockAction::ReadOperations
+pub radroots_storage::workspace::seller_stock::StockAction::ReadPools
+pub radroots_storage::workspace::seller_stock::StockAction::RemoveStock
+pub radroots_storage::workspace::seller_stock::StockAction::SpoilStock
+impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::StockAction
+pub fn radroots_storage::workspace::seller_stock::StockAction::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error>
+pub struct radroots_storage::workspace::seller_stock::SellerAuthoritySelection
+impl radroots_storage::workspace::seller_stock::SellerAuthoritySelection
+pub fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::attachment(&self, radroots_domain::identifier::GrantId) -> core::result::Result<radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::WorkspaceError>
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::authority(&self) -> radroots_domain::context::AuthorityRef
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::capability_contract(&self) -> radroots_storage::workspace::seller_stock::StockCapabilityContract
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::checkpoint(&self) -> &radroots_domain::context::CheckpointRef
+pub fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::endpoint(&self) -> &str
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::endpoint_identity(&self) -> radroots_identity::key::PublicKey
+pub fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment(&radroots_storage::workspace::AttachmentInput) -> Self
+pub fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::matches_attachment(&self, &radroots_storage::workspace::AttachmentInput) -> bool
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::participant(&self) -> radroots_identity::key::PublicKey
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::route_digest(&self) -> radroots_domain::identifier::RouteDigest
+pub const fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::workspace_id(&self) -> radroots_domain::identifier::WorkspaceId
+impl core::fmt::Debug for radroots_storage::workspace::seller_stock::SellerAuthoritySelection
+pub fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::SellerAuthoritySelection
+pub fn radroots_storage::workspace::seller_stock::SellerAuthoritySelection::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error>
pub struct radroots_storage::workspace::seller_stock::SellerStockConfig
impl radroots_storage::workspace::seller_stock::SellerStockConfig
pub fn radroots_storage::workspace::seller_stock::SellerStockConfig::enroll(self, radroots_domain::context::UnixSeconds, radroots_domain::identifier::WorkspaceId, radroots_domain::identifier::ExecutorId, radroots_domain::identifier::GrantId, radroots_storage::workspace::AttachmentProof) -> core::result::Result<(radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof, radroots_storage::workspace::grant::WorkspaceGrant), radroots_storage::workspace::WorkspaceError>
@@ -2359,6 +2390,63 @@ impl radroots_storage::workspace::seller_stock::SellerStockConfig
pub fn radroots_storage::workspace::seller_stock::SellerStockConfig::new(radroots_identity::key::PublicKey, radroots_identity::key::PublicKey, impl core::convert::AsRef<str>, radroots_domain::context::UnixSeconds) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
impl core::fmt::Debug for radroots_storage::workspace::seller_stock::SellerStockConfig
pub fn radroots_storage::workspace::seller_stock::SellerStockConfig::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage::workspace::seller_stock::StockAuthorizationRef
+impl radroots_storage::workspace::seller_stock::StockAuthorizationRef
+pub const fn radroots_storage::workspace::seller_stock::StockAuthorizationRef::digest(self) -> radroots_domain::identifier::CheckpointDigest
+pub fn radroots_storage::workspace::seller_stock::StockAuthorizationRef::from_host_metadata(radroots_domain::context::Sequence, radroots_domain::identifier::CheckpointDigest) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub const fn radroots_storage::workspace::seller_stock::StockAuthorizationRef::generation(self) -> radroots_domain::context::Sequence
+impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::StockAuthorizationRef
+pub fn radroots_storage::workspace::seller_stock::StockAuthorizationRef::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error>
+pub struct radroots_storage::workspace::seller_stock::StockCapabilityContract
+impl radroots_storage::workspace::seller_stock::StockCapabilityContract
+pub const fn radroots_storage::workspace::seller_stock::StockCapabilityContract::id(self) -> &'static str
+pub const fn radroots_storage::workspace::seller_stock::StockCapabilityContract::version(self) -> u16
+impl serde_core::ser::Serialize for radroots_storage::workspace::seller_stock::StockCapabilityContract
+pub fn radroots_storage::workspace::seller_stock::StockCapabilityContract::serialize<S: serde_core::ser::Serializer>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::StockCapabilityContract
+pub fn radroots_storage::workspace::seller_stock::StockCapabilityContract::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error>
+pub struct radroots_storage::workspace::seller_stock::StockGrantRecord
+impl radroots_storage::workspace::seller_stock::StockGrantRecord
+pub const fn radroots_storage::workspace::seller_stock::StockGrantRecord::administrator(&self) -> bool
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::authenticate(&self, &radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof, radroots_domain::context::UnixSeconds) -> core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::authenticate_retained_capture(&self, &radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<(), radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::belongs_to(&self, &radroots_storage::workspace::seller_stock::SellerAuthoritySelection) -> core::result::Result<bool, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::decode(&[u8]) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::encode(&self) -> core::result::Result<zeroize::Zeroizing<alloc::vec::Vec<u8>>, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::expires_at(&self) -> radroots_domain::context::UnixSeconds
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::from_enrollment(radroots_storage::workspace::grant::WorkspaceGrant) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::input(&self) -> &radroots_storage::workspace::AttachmentInput
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::new(radroots_storage::workspace::AttachmentInput, alloc::string::String, radroots_domain::context::UnixSeconds, radroots_storage::workspace::seller_stock::StockGrantScope, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::permissions(&self) -> &radroots_storage::workspace::seller_stock::StockGrantScope
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::revoke(&mut self) -> core::result::Result<(), radroots_storage::workspace::WorkspaceError>
+impl core::fmt::Debug for radroots_storage::workspace::seller_stock::StockGrantRecord
+pub fn radroots_storage::workspace::seller_stock::StockGrantRecord::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage::workspace::seller_stock::StockGrantScope
+impl radroots_storage::workspace::seller_stock::StockGrantScope
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::actions(&self) -> alloc::vec::Vec<radroots_storage::workspace::seller_stock::StockAction>
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::allows(&self, radroots_storage::workspace::seller_stock::StockAction, radroots_domain::identifier::PoolId) -> bool
+pub const fn radroots_storage::workspace::seller_stock::StockGrantScope::allows_action(&self, radroots_storage::workspace::seller_stock::StockAction) -> bool
+pub const fn radroots_storage::workspace::seller_stock::StockGrantScope::full_inventory() -> Self
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::new(radroots_storage::workspace::seller_stock::StockResources, alloc::vec::Vec<radroots_storage::workspace::seller_stock::StockAction>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::resources(&self) -> &radroots_storage::workspace::seller_stock::StockResources
+impl core::fmt::Debug for radroots_storage::workspace::seller_stock::StockGrantScope
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl serde_core::ser::Serialize for radroots_storage::workspace::seller_stock::StockGrantScope
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::serialize<S: serde_core::ser::Serializer>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::StockGrantScope
+pub fn radroots_storage::workspace::seller_stock::StockGrantScope::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error>
+pub struct radroots_storage::workspace::seller_stock::StockResources(_)
+impl radroots_storage::workspace::seller_stock::StockResources
+pub const fn radroots_storage::workspace::seller_stock::StockResources::all_pools() -> Self
+pub fn radroots_storage::workspace::seller_stock::StockResources::contains(&self, radroots_domain::identifier::PoolId) -> bool
+pub fn radroots_storage::workspace::seller_stock::StockResources::pools(alloc::vec::Vec<radroots_domain::identifier::PoolId>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage::workspace::seller_stock::StockResources::selected_pools(&self) -> core::option::Option<&[radroots_domain::identifier::PoolId]>
+impl core::fmt::Debug for radroots_storage::workspace::seller_stock::StockResources
+pub fn radroots_storage::workspace::seller_stock::StockResources::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl serde_core::ser::Serialize for radroots_storage::workspace::seller_stock::StockResources
+pub fn radroots_storage::workspace::seller_stock::StockResources::serialize<S: serde_core::ser::Serializer>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_storage::workspace::seller_stock::StockResources
+pub fn radroots_storage::workspace::seller_stock::StockResources::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error>
#[non_exhaustive] pub enum radroots_storage::workspace::WorkspaceError
pub radroots_storage::workspace::WorkspaceError::Capacity
pub radroots_storage::workspace::WorkspaceError::Closed
@@ -2417,6 +2505,8 @@ pub const fn radroots_storage::workspace::WorkspaceBinding::input(&self) -> &rad
pub const fn radroots_storage::workspace::WorkspaceBinding::observed_at(&self) -> radroots_domain::context::UnixSeconds
pub fn radroots_storage::workspace::WorkspaceBinding::principal_id(&self) -> &str
pub const fn radroots_storage::workspace::WorkspaceBinding::scope(&self) -> radroots_storage::workspace::WorkspaceScope
+pub const fn radroots_storage::workspace::WorkspaceBinding::stock_authorization(&self) -> core::option::Option<radroots_storage::workspace::seller_stock::StockAuthorizationRef>
+pub fn radroots_storage::workspace::WorkspaceBinding::with_stock_authorization(self, radroots_storage::workspace::seller_stock::StockAuthorizationRef) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
impl core::fmt::Debug for radroots_storage::workspace::WorkspaceBinding
pub fn radroots_storage::workspace::WorkspaceBinding::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
pub trait radroots_storage::workspace::WorkspaceClock: radroots_transport::host::HostBound
diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt
@@ -368,6 +368,9 @@ pub use radroots_storage_sqlite::workspace::WorkspaceBinding
pub use radroots_storage_sqlite::workspace::WorkspaceClock
pub use radroots_storage_sqlite::workspace::WorkspaceError
pub use radroots_storage_sqlite::workspace::WorkspaceScope
+pub enum radroots_storage_sqlite::workspace::StockGrantOutcome
+pub radroots_storage_sqlite::workspace::StockGrantOutcome::Committed(radroots_storage_sqlite::workspace::StockGrantReceipt)
+pub radroots_storage_sqlite::workspace::StockGrantOutcome::Unknown(radroots_domain::identifier::TransactionId)
pub struct radroots_storage_sqlite::workspace::NativeWorkspace
impl radroots_storage_sqlite::workspace::NativeWorkspace
pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError>
@@ -376,6 +379,9 @@ pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::initialize_loc
pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::open_existing(&std::path::Path, radroots_storage::workspace::AttachmentInput, radroots_storage_sqlite::workspace::WorkspaceCrypto, alloc::sync::Arc<dyn radroots_storage::workspace::WorkspaceClock>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::revoke(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<(), radroots_storage::workspace::WorkspaceError>
impl radroots_storage_sqlite::workspace::NativeWorkspace
+pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::enroll_stock_grant(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, &radroots_storage::workspace::AttachmentProof, &radroots_storage_sqlite::workspace::StockGrantEnrollment) -> core::result::Result<radroots_storage_sqlite::workspace::StockGrantOutcome, radroots_storage::workspace::WorkspaceError>
+pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::revoke_stock_grant(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, &radroots_storage::workspace::AttachmentProof, radroots_domain::identifier::TransactionId, radroots_domain::identifier::GrantId) -> core::result::Result<radroots_storage_sqlite::workspace::StockGrantOutcome, radroots_storage::workspace::WorkspaceError>
+impl radroots_storage_sqlite::workspace::NativeWorkspace
pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::initialize_seller_stock(&std::path::Path, &radroots_storage_sqlite::workspace::StockEnrollment, radroots_storage_sqlite::workspace::WorkspaceCrypto, alloc::sync::Arc<dyn radroots_storage::workspace::WorkspaceClock>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::open_seller_stock(&std::path::Path, radroots_storage::workspace::AttachmentInput, radroots_storage_sqlite::workspace::WorkspaceCrypto, alloc::sync::Arc<dyn radroots_storage::workspace::WorkspaceClock>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_authority(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockAuthorityReceipt, radroots_storage::workspace::WorkspaceError>
@@ -418,6 +424,19 @@ pub fn radroots_storage_sqlite::workspace::StockEnrollment::proof(&self) -> &rad
pub const fn radroots_storage_sqlite::workspace::StockEnrollment::transaction_id(&self) -> radroots_domain::identifier::TransactionId
impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockEnrollment
pub fn radroots_storage_sqlite::workspace::StockEnrollment::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage_sqlite::workspace::StockGrantEnrollment
+impl radroots_storage_sqlite::workspace::StockGrantEnrollment
+pub fn radroots_storage_sqlite::workspace::StockGrantEnrollment::input(&self) -> &radroots_storage::workspace::AttachmentInput
+pub fn radroots_storage_sqlite::workspace::StockGrantEnrollment::prepare(&radroots_storage::workspace::seller_stock::selection::SellerAuthoritySelection, alloc::string::String, radroots_domain::context::UnixSeconds, radroots_storage::workspace::seller_stock::permissions::StockGrantScope) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
+pub fn radroots_storage_sqlite::workspace::StockGrantEnrollment::proof(&self) -> &radroots_storage::workspace::AttachmentProof
+pub const fn radroots_storage_sqlite::workspace::StockGrantEnrollment::transaction_id(&self) -> radroots_domain::identifier::TransactionId
+impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockGrantEnrollment
+pub fn radroots_storage_sqlite::workspace::StockGrantEnrollment::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage_sqlite::workspace::StockGrantReceipt
+impl radroots_storage_sqlite::workspace::StockGrantReceipt
+pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::authorization(&self) -> radroots_storage::workspace::seller_stock::authorization::StockAuthorizationRef
+pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::grant_id(&self) -> radroots_domain::identifier::GrantId
+pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId
pub struct radroots_storage_sqlite::workspace::WorkspaceCrypto
impl radroots_storage_sqlite::workspace::WorkspaceCrypto
pub fn radroots_storage_sqlite::workspace::WorkspaceCrypto::new(alloc::sync::Arc<dyn radroots_secrets::provider::SecretProvider>, radroots_secrets::id::SecretRef, radroots_secrets::wrapping::SecretMaterial, radroots_secrets::provider::AccessPolicy) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError>
diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json
@@ -58,7 +58,10 @@
"seller_owner_executor_optional_to_single_device": true
},
"local_outbox_authority": {
- "scopes": ["new_buyer_outbox", "new_seller_outbox"],
+ "scopes": [
+ "new_buyer_outbox",
+ "new_seller_outbox"
+ ],
"seller_enrollment_explicit": true,
"scope_retained_in_authenticated_binding_and_preparation": true,
"legacy_preparation_v2_scope": "new_buyer_outbox",
@@ -72,11 +75,16 @@
"scope": "seller_stock_owner",
"database": "stock_execution_v1.sqlite",
"lock": ".stock_execution_v1.lock",
- "schema_version": 3,
- "retained_enrollment_versions": [1],
- "retained_inventory_versions": [2],
- "authority_payload_schema": "radroots.seller_stock.authority.v3",
- "inventory_operation_payload_schema": "radroots.seller_stock.operation.v2",
+ "schema_version": 4,
+ "retained_enrollment_versions": [
+ 1
+ ],
+ "retained_inventory_versions": [
+ 2,
+ 3
+ ],
+ "authority_payload_schema": "radroots.seller_stock.authority.v4",
+ "inventory_operation_payload_schema": "radroots.seller_stock.operation.v3",
"inventory_movement_payload_schema": "radroots.seller_stock.movement.v2",
"pool_tick_scale_explicit": true,
"pool_tick_scale_encoding": "canonical_integer_string",
@@ -88,7 +96,33 @@
"protected_authority_and_grants_separate": true,
"automatic_outbox_migration": false,
"historical_obligations_recovered": false,
- "business_effects_qualified": false
+ "business_effects_qualified": false,
+ "grant_payload_schema": "radroots.seller_stock.grant.v2",
+ "grant_change_payload_schema": "radroots.seller_stock.grant_change.v1",
+ "namespace_excludes_caller_grant": true,
+ "actor_operation_unique_across_grants": true,
+ "grant_checkpoint_minimum_required": true,
+ "grant_checkpoint_policy": "exact_current_for_fresh_work_original_prior_for_exact_admin_recovery",
+ "grant_set_max": 64,
+ "grant_pool_scope_max": 64,
+ "grant_action_max": 6,
+ "grant_scope_actions": [
+ "read_pools",
+ "read_operations",
+ "create_pool",
+ "add_stock",
+ "remove_stock",
+ "spoil_stock"
+ ],
+ "grant_write_requires_receipt_and_recovery_read": true,
+ "inventory_scope_grants_administration": false,
+ "grant_admin_prepared_transaction_required": true,
+ "retained_grants_automatically_evicted": false,
+ "old_self_revoke_api_supported": false,
+ "capability_contract": {
+ "id": "radroots.seller_stock.native_inventory",
+ "version": "1"
+ }
},
"provenance": {
"app_behavior_implementation": "independent_reimplementation",
diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs
@@ -13,6 +13,7 @@ pub struct InventoryRequest {
binding: WorkspaceBinding,
minimum: InventoryCheckpointRef,
command: CapturedInventoryCommand,
+ replay_only: bool,
}
impl InventoryRequest {
pub fn new(
@@ -20,16 +21,40 @@ impl InventoryRequest {
minimum: InventoryCheckpointRef,
command: impl Into<CapturedInventoryCommand>,
) -> Result<Self, OperationError> {
- let command = command.into();
+ Self::build(binding, minimum, command.into(), false)
+ }
+ /// An explicitly retained original command under a current grant. A missing
+ /// original operation requires recovery and can never create a fresh effect.
+ pub fn replay_from_protected_wire(
+ binding: WorkspaceBinding,
+ minimum: InventoryCheckpointRef,
+ wire: &[u8],
+ ) -> Result<Self, OperationError> {
+ Self::build(
+ binding,
+ minimum,
+ CapturedInventoryCommand::parse(wire).map_err(|_| OperationError::RecoveryRequired)?,
+ true,
+ )
+ }
+ fn build(
+ binding: WorkspaceBinding,
+ minimum: InventoryCheckpointRef,
+ command: CapturedInventoryCommand,
+ replay_only: bool,
+ ) -> Result<Self, OperationError> {
let context = command.context();
let selection = binding.input();
if binding.scope() != WorkspaceScope::SellerStockOwner {
return Err(OperationError::Unauthorized);
}
- if context.workspace_id() != selection.workspace_id()
+ if (!replay_only && context.actor() != binding.actor())
+ || context.workspace_id() != selection.workspace_id()
|| context.authority() != selection.authority()
|| context.route_digest() != selection.route_digest()
- || context.actor() != binding.actor()
+ || context.actor().participant() != binding.actor().participant()
+ || context.actor().role() != binding.actor().role()
+ || context.actor().organization() != binding.actor().organization()
{
return Err(OperationError::InvalidCommand);
}
@@ -49,6 +74,7 @@ impl InventoryRequest {
binding,
minimum,
command,
+ replay_only,
})
}
/// Reconstructs captured data only; the concrete host must reauthenticate it.
@@ -73,12 +99,16 @@ impl InventoryRequest {
pub const fn command(&self) -> &CapturedInventoryCommand {
&self.command
}
+ pub const fn replay_only(&self) -> bool {
+ self.replay_only
+ }
pub fn retained_copy(&self) -> Result<Self, OperationError> {
- Self::new(
+ Self::build(
self.binding.clone(),
self.minimum,
CapturedInventoryCommand::parse(self.command.protected_wire())
.map_err(|_| OperationError::RecoveryRequired)?,
+ self.replay_only,
)
}
}
@@ -94,6 +124,7 @@ pub struct InventoryCheckpointRef {
authority: radroots_domain::AuthorityRef,
revision: radroots_domain::Sequence,
head: Option<radroots_domain::CheckpointDigest>,
+ authorization: Option<crate::workspace::seller_stock::StockAuthorizationRef>,
}
impl InventoryCheckpointRef {
pub fn from_host_metadata(
@@ -108,8 +139,30 @@ impl InventoryCheckpointRef {
authority,
revision,
head,
+ authorization: None,
})
}
+ /// Binds an independently retained authorization-state observation. Metadata
+ /// alone supplies neither credential possession nor checkpoint provenance.
+ pub const fn with_authorization(
+ mut self,
+ value: crate::workspace::seller_stock::StockAuthorizationRef,
+ ) -> Self {
+ self.authorization = Some(value);
+ self
+ }
+ pub const fn with_optional_authorization(
+ mut self,
+ value: Option<crate::workspace::seller_stock::StockAuthorizationRef>,
+ ) -> Self {
+ self.authorization = value;
+ self
+ }
+ pub const fn authorization(
+ self,
+ ) -> Option<crate::workspace::seller_stock::StockAuthorizationRef> {
+ self.authorization
+ }
pub const fn authority(self) -> radroots_domain::AuthorityRef {
self.authority
}
diff --git a/crates/storage/src/workspace.rs b/crates/storage/src/workspace.rs
@@ -247,6 +247,8 @@ pub struct WorkspaceBinding {
grant_revision: Sequence,
expires_at: UnixSeconds,
observed_at: UnixSeconds,
+ #[cfg(feature = "protected_outbox")]
+ stock_authorization: Option<seller_stock::StockAuthorizationRef>,
}
impl WorkspaceBinding {
/// Checks the internal binding of a trusted storage adapter's observation.
@@ -284,8 +286,26 @@ impl WorkspaceBinding {
grant_revision,
expires_at,
observed_at,
+ #[cfg(feature = "protected_outbox")]
+ stock_authorization: None,
})
}
+ /// Adds qualified stock-host observation metadata, never credential authority.
+ #[cfg(feature = "protected_outbox")]
+ pub fn with_stock_authorization(
+ mut self,
+ value: seller_stock::StockAuthorizationRef,
+ ) -> Result<Self, WorkspaceError> {
+ if self.scope != WorkspaceScope::SellerStockOwner {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ self.stock_authorization = Some(value);
+ Ok(self)
+ }
+ #[cfg(feature = "protected_outbox")]
+ pub const fn stock_authorization(&self) -> Option<seller_stock::StockAuthorizationRef> {
+ self.stock_authorization
+ }
/// Borrows the exact authenticated selection.
pub const fn input(&self) -> &AttachmentInput {
&self.input
diff --git a/crates/storage/src/workspace/grant.rs b/crates/storage/src/workspace/grant.rs
@@ -39,6 +39,12 @@ impl Drop for WorkspaceGrant {
}
}
impl WorkspaceGrant {
+ pub(super) fn expires_at(&self) -> UnixSeconds {
+ self.wire.expires_at
+ }
+ pub(super) fn input(&self) -> &AttachmentInput {
+ &self.wire.input
+ }
pub fn new(
input: AttachmentInput,
actor: ActorRef,
diff --git a/crates/storage/src/workspace/seller_stock.rs b/crates/storage/src/workspace/seller_stock.rs
@@ -8,6 +8,12 @@ use radroots_domain::{
GrantId, PublicKey, RouteDigest, Sequence, UnixSeconds, WorkspaceId,
};
use sha2::{Digest, Sha256};
+mod authorization;
+pub use authorization::{StockAuthorizationRef, StockGrantRecord};
+mod selection;
+pub use selection::{SellerAuthoritySelection, StockCapabilityContract};
+mod permissions;
+pub use permissions::{StockAction, StockGrantScope, StockResources};
/// Explicit local enrollment inputs, supplied by a trusted host interaction.
/// Only a qualified stock host may persist the resulting authority.
pub struct SellerStockConfig {
diff --git a/crates/storage/src/workspace/seller_stock/authorization.rs b/crates/storage/src/workspace/seller_stock/authorization.rs
@@ -0,0 +1,195 @@
+//! Explicit protected stock grants and authorization checkpoint metadata.
+use super::{SellerAuthoritySelection, StockGrantScope};
+use crate::workspace::{
+ AttachmentInput, AttachmentProof, WorkspaceBinding, WorkspaceError, WorkspaceScope,
+ grant::WorkspaceGrant,
+};
+use radroots_domain::{ActorRef, CheckpointDigest, Sequence, UnixSeconds};
+use serde::{Deserialize, Serialize};
+
+/// A claimed protected grant-set observation. It never authenticates a caller.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct StockAuthorizationRef {
+ generation: Sequence,
+ digest: CheckpointDigest,
+}
+impl<'de> Deserialize<'de> for StockAuthorizationRef {
+ fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+ #[derive(Deserialize)]
+ #[serde(deny_unknown_fields)]
+ struct Wire {
+ generation: Sequence,
+ digest: CheckpointDigest,
+ }
+ struct Visitor;
+ impl<'de> serde::de::Visitor<'de> for Visitor {
+ type Value = Wire;
+ fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("a closed authorization checkpoint object")
+ }
+ fn visit_map<A: serde::de::MapAccess<'de>>(self, map: A) -> Result<Wire, A::Error> {
+ Wire::deserialize(serde::de::value::MapAccessDeserializer::new(map))
+ }
+ }
+ let v = deserializer.deserialize_map(Visitor)?;
+ Self::from_host_metadata(v.generation, v.digest).map_err(serde::de::Error::custom)
+ }
+}
+impl StockAuthorizationRef {
+ pub fn from_host_metadata(
+ generation: Sequence,
+ digest: CheckpointDigest,
+ ) -> Result<Self, WorkspaceError> {
+ if generation.get() == 0 {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ Ok(Self { generation, digest })
+ }
+ pub const fn generation(self) -> Sequence {
+ self.generation
+ }
+ pub const fn digest(self) -> CheckpointDigest {
+ self.digest
+ }
+}
+
+/// Closed stock-only grant. The envelope and current namespace/grant-set must
+/// be authenticated by the concrete host before these claims are consumed.
+pub struct StockGrantRecord {
+ credential: WorkspaceGrant,
+ permissions: StockGrantScope,
+ administrator: bool,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Wire<'a> {
+ version: u8,
+ #[serde(borrow)]
+ credential: &'a serde_json::value::RawValue,
+ permissions: StockGrantScope,
+ administrator: bool,
+}
+impl StockGrantRecord {
+ pub fn new(
+ input: AttachmentInput,
+ principal: String,
+ expires_at: UnixSeconds,
+ permissions: StockGrantScope,
+ proof: &AttachmentProof,
+ ) -> Result<Self, WorkspaceError> {
+ let actor = ActorRef::new(
+ input.participant(),
+ WorkspaceScope::SellerStockOwner.actor_role(),
+ None,
+ Some(input.grant_id()),
+ );
+ let credential = WorkspaceGrant::with_scope(
+ input,
+ WorkspaceScope::SellerStockOwner,
+ actor,
+ principal,
+ expires_at,
+ proof,
+ )?;
+ Ok(Self {
+ credential,
+ permissions,
+ administrator: false,
+ })
+ }
+ /// Only fresh authority enrollment supplies the original administrative grant.
+ /// Hosts must never treat construction of this metadata as authorization.
+ pub fn from_enrollment(credential: WorkspaceGrant) -> Result<Self, WorkspaceError> {
+ if credential.scope() != WorkspaceScope::SellerStockOwner {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ Ok(Self {
+ credential,
+ permissions: StockGrantScope::full_inventory(),
+ administrator: true,
+ })
+ }
+ pub fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> {
+ let clear = self.credential.encode()?;
+ let credential: &serde_json::value::RawValue =
+ serde_json::from_slice(&clear).map_err(|_| WorkspaceError::StorageFailure)?;
+ let bytes = zeroize::Zeroizing::new(
+ serde_json::to_vec(&Wire {
+ version: 2,
+ credential,
+ permissions: self.permissions.clone(),
+ administrator: self.administrator,
+ })
+ .map_err(|_| WorkspaceError::StorageFailure)?,
+ );
+ if bytes.len() > 16 * 1024 {
+ return Err(WorkspaceError::Capacity);
+ }
+ Ok(bytes)
+ }
+ pub fn decode(bytes: &[u8]) -> Result<Self, WorkspaceError> {
+ if bytes.len() > 16 * 1024
+ || bytes.iter().copied().find(|b| !b.is_ascii_whitespace()) != Some(b'{')
+ {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ let wire: Wire<'_> =
+ serde_json::from_slice(bytes).map_err(|_| WorkspaceError::RecoveryRequired)?;
+ if wire.version != 2 {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ if !wire.credential.get().starts_with('{') {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ let credential = WorkspaceGrant::decode(wire.credential.get().as_bytes())?;
+ if credential.scope() != WorkspaceScope::SellerStockOwner
+ || (wire.administrator && wire.permissions != StockGrantScope::full_inventory())
+ {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ Ok(Self {
+ credential,
+ permissions: wire.permissions,
+ administrator: wire.administrator,
+ })
+ }
+ pub fn input(&self) -> &AttachmentInput {
+ self.credential.input()
+ }
+ pub fn expires_at(&self) -> UnixSeconds {
+ self.credential.expires_at()
+ }
+ pub fn permissions(&self) -> &StockGrantScope {
+ &self.permissions
+ }
+ pub const fn administrator(&self) -> bool {
+ self.administrator
+ }
+ pub fn authenticate(
+ &self,
+ input: &AttachmentInput,
+ proof: &AttachmentProof,
+ now: UnixSeconds,
+ ) -> Result<WorkspaceBinding, WorkspaceError> {
+ self.credential.authenticate(input, proof, now)
+ }
+ pub fn authenticate_retained_capture(
+ &self,
+ input: &AttachmentInput,
+ proof: &AttachmentProof,
+ ) -> Result<(), WorkspaceError> {
+ self.credential.authenticate_retained_capture(input, proof)
+ }
+ pub fn revoke(&mut self) -> Result<(), WorkspaceError> {
+ self.credential.revoke()
+ }
+ pub fn belongs_to(&self, namespace: &SellerAuthoritySelection) -> Result<bool, WorkspaceError> {
+ Ok(namespace.matches_attachment(self.credential.input()))
+ }
+}
+impl core::fmt::Debug for StockGrantRecord {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("StockGrantRecord(<redacted>)")
+ }
+}
diff --git a/crates/storage/src/workspace/seller_stock/permissions.rs b/crates/storage/src/workspace/seller_stock/permissions.rs
@@ -0,0 +1,254 @@
+//! Bounded inventory permission claims. A qualified host must authenticate the
+//! protected grant and its current principal, expiry and revocation separately.
+use crate::workspace::WorkspaceError;
+use radroots_domain::PoolId;
+
+/// One explicit inventory capability; no signer or grant-administration right.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+pub enum StockAction {
+ ReadPools,
+ ReadOperations,
+ CreatePool,
+ AddStock,
+ RemoveStock,
+ SpoilStock,
+}
+impl StockAction {
+ const ALL: [Self; 6] = [
+ Self::ReadPools,
+ Self::ReadOperations,
+ Self::CreatePool,
+ Self::AddStock,
+ Self::RemoveStock,
+ Self::SpoilStock,
+ ];
+ const fn bit(self) -> u8 {
+ match self {
+ Self::ReadPools => 1,
+ Self::ReadOperations => 2,
+ Self::CreatePool => 4,
+ Self::AddStock => 8,
+ Self::RemoveStock => 16,
+ Self::SpoilStock => 32,
+ }
+ }
+}
+/// Explicit all-pool selection or at most64 sorted unique private pool IDs.
+#[derive(Clone, Eq, PartialEq)]
+pub struct StockResources(Option<Box<[PoolId]>>);
+impl StockResources {
+ /// Claims every pool in this selected seller namespace, without authority.
+ pub const fn all_pools() -> Self {
+ Self(None)
+ }
+ /// Requires canonical ascending unique IDs; empty never means all pools.
+ pub fn pools(pools: Vec<PoolId>) -> Result<Self, WorkspaceError> {
+ if pools.is_empty() || pools.len() > 64 || pools.windows(2).any(|v| v[0] >= v[1]) {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ Ok(Self(Some(pools.into_boxed_slice())))
+ }
+ /// Tests only the declared resource set, never authenticated permission.
+ pub fn contains(&self, pool: PoolId) -> bool {
+ self.0
+ .as_ref()
+ .is_none_or(|ids| ids.binary_search(&pool).is_ok())
+ }
+ /// None denotes the explicit all-pools variant; a selected set is nonempty.
+ pub fn selected_pools(&self) -> Option<&[PoolId]> {
+ self.0.as_deref()
+ }
+}
+impl core::fmt::Debug for StockResources {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("StockResources(<redacted>)")
+ }
+}
+/// Action/resource claims for one namespace. Write scopes explicitly include
+/// pool and operation reads needed for checked effects and original recovery.
+/// This constructor grants no permission and cannot create or update a grant.
+#[derive(Clone, Eq, PartialEq)]
+pub struct StockGrantScope {
+ resources: StockResources,
+ mask: u8,
+}
+impl StockGrantScope {
+ /// Requires nonempty actions in the declared enum order, without duplicates.
+ pub fn new(
+ resources: StockResources,
+ actions: Vec<StockAction>,
+ ) -> Result<Self, WorkspaceError> {
+ if actions.is_empty()
+ || actions.len() > 6
+ || actions.windows(2).any(|v| v[0].bit() >= v[1].bit())
+ {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ let mask = actions
+ .into_iter()
+ .fold(0, |mask, action| mask | action.bit());
+ if mask & !3 != 0 && mask & 3 != 3 {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ Ok(Self { resources, mask })
+ }
+ /// Explicit full inventory claim; it includes no grant control or signing.
+ pub const fn full_inventory() -> Self {
+ Self {
+ resources: StockResources::all_pools(),
+ mask: 63,
+ }
+ }
+ /// Canonical bounded declared actions.
+ pub fn actions(&self) -> Vec<StockAction> {
+ StockAction::ALL
+ .into_iter()
+ .filter(|action| self.allows_action(*action))
+ .collect()
+ }
+ pub fn resources(&self) -> &StockResources {
+ &self.resources
+ }
+ /// Evaluates only a declared action, without grant authentication.
+ pub const fn allows_action(&self, action: StockAction) -> bool {
+ self.mask & action.bit() != 0
+ }
+ /// Evaluates the complete declared action/resource pair.
+ pub fn allows(&self, action: StockAction, pool: PoolId) -> bool {
+ self.allows_action(action) && self.resources.contains(pool)
+ }
+}
+impl core::fmt::Debug for StockGrantScope {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("StockGrantScope(<untrusted descriptor>)")
+ }
+}
+
+#[cfg(feature = "serde")]
+mod serialization {
+ use super::*;
+ use serde::{Deserialize, Deserializer, Serialize, Serializer, de, ser::SerializeStruct};
+ impl<'de> Deserialize<'de> for StockAction {
+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+ struct Visitor;
+ impl de::Visitor<'_> for Visitor {
+ type Value = StockAction;
+ fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("one exact stock action string")
+ }
+ fn visit_str<E: de::Error>(self, v: &str) -> Result<StockAction, E> {
+ match v {
+ "read_pools" => Ok(StockAction::ReadPools),
+ "read_operations" => Ok(StockAction::ReadOperations),
+ "create_pool" => Ok(StockAction::CreatePool),
+ "add_stock" => Ok(StockAction::AddStock),
+ "remove_stock" => Ok(StockAction::RemoveStock),
+ "spoil_stock" => Ok(StockAction::SpoilStock),
+ _ => Err(E::custom("invalid stock action")),
+ }
+ }
+ }
+ d.deserialize_str(Visitor)
+ }
+ }
+ fn bounded<'de, D: Deserializer<'de>, T: Deserialize<'de>, const N: usize>(
+ d: D,
+ ) -> Result<Vec<T>, D::Error> {
+ struct Visitor<T, const N: usize>(core::marker::PhantomData<T>);
+ impl<'de, T: Deserialize<'de>, const N: usize> de::Visitor<'de> for Visitor<T, N> {
+ type Value = Vec<T>;
+ fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("a bounded scope array")
+ }
+ fn visit_seq<A: de::SeqAccess<'de>>(self, mut seq: A) -> Result<Vec<T>, A::Error> {
+ let mut values = Vec::new();
+ while let Some(value) = seq.next_element()? {
+ if values.len() == N {
+ return Err(de::Error::custom("scope array limit exceeded"));
+ }
+ values.push(value);
+ }
+ Ok(values)
+ }
+ }
+ d.deserialize_seq(Visitor::<T, N>(core::marker::PhantomData))
+ }
+ fn object<'de, D: Deserializer<'de>, T: Deserialize<'de>>(d: D) -> Result<T, D::Error> {
+ struct Visitor<T>(core::marker::PhantomData<T>);
+ impl<'de, T: Deserialize<'de>> de::Visitor<'de> for Visitor<T> {
+ type Value = T;
+ fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("a closed stock scope object")
+ }
+ fn visit_map<A: de::MapAccess<'de>>(self, map: A) -> Result<T, A::Error> {
+ T::deserialize(de::value::MapAccessDeserializer::new(map))
+ }
+ }
+ d.deserialize_map(Visitor(core::marker::PhantomData))
+ }
+ impl Serialize for StockResources {
+ fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+ let mut wire =
+ s.serialize_struct("StockResources", if self.0.is_some() { 2 } else { 1 })?;
+ if let Some(ids) = &self.0 {
+ wire.serialize_field("ids", ids)?;
+ }
+ wire.serialize_field(
+ "type",
+ if self.0.is_some() {
+ "pools"
+ } else {
+ "all_pools"
+ },
+ )?;
+ wire.end()
+ }
+ }
+ impl<'de> Deserialize<'de> for StockResources {
+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+ fn ids<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Vec<PoolId>>, D::Error> {
+ bounded::<D, PoolId, 64>(d).map(Some)
+ }
+ #[derive(Deserialize)]
+ #[serde(deny_unknown_fields)]
+ struct Wire {
+ #[serde(rename = "type")]
+ kind: String,
+ #[serde(default, deserialize_with = "ids")]
+ ids: Option<Vec<PoolId>>,
+ }
+ let wire: Wire = object(d)?;
+ match (wire.kind.as_str(), wire.ids) {
+ ("all_pools", None) => Ok(Self::all_pools()),
+ ("pools", Some(ids)) => Self::pools(ids).map_err(de::Error::custom),
+ _ => Err(de::Error::custom("invalid stock resources")),
+ }
+ }
+ }
+ impl Serialize for StockGrantScope {
+ fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+ let mut wire = s.serialize_struct("StockGrantScope", 2)?;
+ wire.serialize_field("actions", &self.actions())?;
+ wire.serialize_field("resources", &self.resources)?;
+ wire.end()
+ }
+ }
+ impl<'de> Deserialize<'de> for StockGrantScope {
+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+ fn actions<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<StockAction>, D::Error> {
+ bounded::<D, StockAction, 6>(d)
+ }
+ #[derive(Deserialize)]
+ #[serde(deny_unknown_fields)]
+ struct Wire {
+ resources: StockResources,
+ #[serde(deserialize_with = "actions")]
+ actions: Vec<StockAction>,
+ }
+ let wire: Wire = object(d)?;
+ Self::new(wire.resources, wire.actions).map_err(de::Error::custom)
+ }
+ }
+}
diff --git a/crates/storage/src/workspace/seller_stock/selection.rs b/crates/storage/src/workspace/seller_stock/selection.rs
@@ -0,0 +1,193 @@
+//! Caller-independent seller namespace metadata, without authority or custody.
+use crate::workspace::{AttachmentInput, WorkspaceError};
+use radroots_domain::{AuthorityRef, CheckpointRef, GrantId, PublicKey, RouteDigest, WorkspaceId};
+
+/// The source-owned concrete local inventory contract supported by this host.
+/// This is neither a public event-kind allocation nor remote pairing evidence.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct StockCapabilityContract;
+impl StockCapabilityContract {
+ pub const fn id(self) -> &'static str {
+ "radroots.seller_stock.native_inventory"
+ }
+ pub const fn version(self) -> u16 {
+ 1
+ }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for StockCapabilityContract {
+ fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+ use serde::ser::SerializeStruct;
+ let mut value = serializer.serialize_struct("StockCapabilityContract", 2)?;
+ value.serialize_field("id", self.id())?;
+ value.serialize_field("version", "1")?;
+ value.end()
+ }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for StockCapabilityContract {
+ fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+ #[derive(serde::Deserialize)]
+ #[serde(deny_unknown_fields)]
+ struct Wire {
+ id: String,
+ version: String,
+ }
+ struct Visitor;
+ impl<'de> serde::de::Visitor<'de> for Visitor {
+ type Value = Wire;
+ fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("the supported native inventory contract object")
+ }
+ fn visit_map<A: serde::de::MapAccess<'de>>(self, map: A) -> Result<Wire, A::Error> {
+ <Wire as serde::Deserialize>::deserialize(
+ serde::de::value::MapAccessDeserializer::new(map),
+ )
+ }
+ }
+ let v = deserializer.deserialize_map(Visitor)?;
+ if v.id != Self.id() || v.version != "1" {
+ return Err(serde::de::Error::custom(
+ "unsupported native inventory contract",
+ ));
+ }
+ Ok(Self)
+ }
+}
+/// Exact namespace, authority and route selection. A caller grant is supplied
+/// separately. This metadata authenticates neither an endpoint nor a writer,
+/// and its checkpoint establishes no independently protected provenance.
+#[derive(Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+pub struct SellerAuthoritySelection {
+ capability_contract: StockCapabilityContract,
+ workspace_id: WorkspaceId,
+ authority: AuthorityRef,
+ participant: PublicKey,
+ endpoint: Box<str>,
+ endpoint_identity: PublicKey,
+ checkpoint: CheckpointRef,
+ route_digest: RouteDigest,
+}
+impl SellerAuthoritySelection {
+ /// Preserves all validated namespace fields while omitting the caller grant.
+ pub fn from_attachment(input: &AttachmentInput) -> Self {
+ Self {
+ capability_contract: StockCapabilityContract,
+ workspace_id: input.workspace_id(),
+ authority: input.authority(),
+ participant: input.participant(),
+ endpoint: input.endpoint().into(),
+ endpoint_identity: input.endpoint_identity(),
+ checkpoint: input.checkpoint().clone(),
+ route_digest: input.route_digest(),
+ }
+ }
+ /// Selects a claimed caller grant; this creates no credential or permission.
+ pub fn attachment(&self, grant: GrantId) -> Result<AttachmentInput, WorkspaceError> {
+ AttachmentInput::new(
+ self.workspace_id,
+ self.authority,
+ self.participant,
+ self.endpoint.to_string(),
+ self.endpoint_identity,
+ grant,
+ self.checkpoint.clone(),
+ self.route_digest,
+ )
+ }
+ /// Compares complete namespace metadata independently of the caller grant.
+ pub fn matches_attachment(&self, input: &AttachmentInput) -> bool {
+ self.workspace_id == input.workspace_id()
+ && self.authority == input.authority()
+ && self.participant == input.participant()
+ && self.endpoint.as_ref() == input.endpoint()
+ && self.endpoint_identity == input.endpoint_identity()
+ && &self.checkpoint == input.checkpoint()
+ && self.route_digest == input.route_digest()
+ }
+ pub const fn capability_contract(&self) -> StockCapabilityContract {
+ self.capability_contract
+ }
+ /// Selected private namespace identity.
+ pub const fn workspace_id(&self) -> WorkspaceId {
+ self.workspace_id
+ }
+ /// Selected executor and authority generation.
+ pub const fn authority(&self) -> AuthorityRef {
+ self.authority
+ }
+ /// Declared stock owner, without signer or actor proof.
+ pub const fn participant(&self) -> PublicKey {
+ self.participant
+ }
+ /// Explicit selected route endpoint, without pairing or endpoint trust.
+ pub fn endpoint(&self) -> &str {
+ &self.endpoint
+ }
+ /// Pinned claimed application identity.
+ pub const fn endpoint_identity(&self) -> PublicKey {
+ self.endpoint_identity
+ }
+ /// Required checkpoint claim, without custody or coverage provenance.
+ pub const fn checkpoint(&self) -> &CheckpointRef {
+ &self.checkpoint
+ }
+ /// Exact declared route commitment.
+ pub const fn route_digest(&self) -> RouteDigest {
+ self.route_digest
+ }
+}
+impl core::fmt::Debug for SellerAuthoritySelection {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("SellerAuthoritySelection(<untrusted descriptor>)")
+ }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SellerAuthoritySelection {
+ fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+ #[derive(serde::Deserialize)]
+ #[serde(deny_unknown_fields)]
+ struct Wire {
+ capability_contract: StockCapabilityContract,
+ workspace_id: WorkspaceId,
+ authority: AuthorityRef,
+ participant: PublicKey,
+ endpoint: String,
+ endpoint_identity: PublicKey,
+ checkpoint: CheckpointRef,
+ route_digest: RouteDigest,
+ }
+ struct Visitor;
+ impl<'de> serde::de::Visitor<'de> for Visitor {
+ type Value = Wire;
+ fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("a closed seller namespace object")
+ }
+ fn visit_map<A: serde::de::MapAccess<'de>>(self, map: A) -> Result<Wire, A::Error> {
+ <Wire as serde::Deserialize>::deserialize(
+ serde::de::value::MapAccessDeserializer::new(map),
+ )
+ }
+ }
+ let v = deserializer.deserialize_map(Visitor)?;
+ if v.endpoint.is_empty()
+ || v.endpoint.len() > 2048
+ || v.endpoint.chars().any(char::is_control)
+ {
+ return Err(serde::de::Error::custom(
+ "invalid seller namespace selection",
+ ));
+ }
+ Ok(Self {
+ capability_contract: v.capability_contract,
+ workspace_id: v.workspace_id,
+ authority: v.authority,
+ participant: v.participant,
+ endpoint: v.endpoint.into_boxed_str(),
+ endpoint_identity: v.endpoint_identity,
+ checkpoint: v.checkpoint,
+ route_digest: v.route_digest,
+ })
+ }
+}
diff --git a/crates/storage/tests/workspace.rs b/crates/storage/tests/workspace.rs
@@ -27,6 +27,221 @@ fn input() -> AttachmentInput {
)
.unwrap()
}
+
+#[cfg(feature = "protected_outbox")]
+#[test]
+fn declared_stock_grants_are_explicit_bounded_and_never_expand_empty_or_reordered_scopes() {
+ use radroots_domain::PoolId;
+ use radroots_storage::workspace::seller_stock::{
+ StockAction::*, StockGrantScope, StockResources,
+ };
+ let first = PoolId::from_bytes([1; 32]);
+ let second = PoolId::from_bytes([2; 32]);
+ assert!(StockResources::pools(vec![]).is_err());
+ assert!(StockResources::pools(vec![first, first]).is_err());
+ assert!(StockResources::pools(vec![second, first]).is_err());
+ assert!(StockResources::pools((0..65).map(|n| PoolId::from_bytes([n; 32])).collect()).is_err());
+ assert!(StockGrantScope::new(StockResources::all_pools(), vec![]).is_err());
+ for actions in [
+ vec![AddStock],
+ vec![ReadPools, AddStock],
+ vec![ReadOperations, AddStock],
+ vec![ReadOperations, ReadPools],
+ vec![ReadPools, ReadPools],
+ ] {
+ assert!(StockGrantScope::new(StockResources::all_pools(), actions).is_err());
+ }
+ let scope = StockGrantScope::new(
+ StockResources::pools(vec![first]).unwrap(),
+ vec![ReadPools, ReadOperations, AddStock],
+ )
+ .unwrap();
+ assert!(scope.allows(AddStock, first));
+ assert!(!scope.allows(AddStock, second));
+ assert!(!scope.allows(RemoveStock, first));
+ assert!(!scope.allows(SpoilStock, first));
+ assert_eq!(scope.actions(), vec![ReadPools, ReadOperations, AddStock]);
+ assert_eq!(scope.resources().selected_pools(), Some(&[first][..]));
+ let readonly =
+ StockGrantScope::new(StockResources::pools(vec![first]).unwrap(), vec![ReadPools]).unwrap();
+ assert!(readonly.allows(ReadPools, first));
+ assert!(!readonly.allows(ReadOperations, first));
+ assert!(!readonly.allows(AddStock, first));
+ let full = StockGrantScope::full_inventory();
+ assert_eq!(
+ full.actions(),
+ vec![
+ ReadPools,
+ ReadOperations,
+ CreatePool,
+ AddStock,
+ RemoveStock,
+ SpoilStock
+ ]
+ );
+ assert!(full.allows(SpoilStock, second));
+ assert_eq!(
+ format!("{scope:?}"),
+ "StockGrantScope(<untrusted descriptor>)"
+ );
+ assert_eq!(
+ format!("{:?}", scope.resources()),
+ "StockResources(<redacted>)"
+ );
+}
+
+#[cfg(all(feature = "protected_outbox", feature = "serde"))]
+#[test]
+fn closed_stock_scope_codecs_reject_aliases_extras_and_implicit_wildcards() {
+ use radroots_storage::workspace::seller_stock::StockGrantScope;
+ use serde_json::json;
+ let valid = json!({"actions":["read_pools","read_operations","add_stock"],"resources":{"type":"pools","ids":["01".repeat(32)]}});
+ let scope: StockGrantScope = serde_json::from_value(valid.clone()).unwrap();
+ assert_eq!(serde_json::to_value(scope).unwrap(), valid);
+ for invalid in [
+ json!({"actions":[],"resources":{"type":"all_pools"}}),
+ json!({"actions":["add_stock"],"resources":{"type":"all_pools"}}),
+ json!({"actions":["read_pools"],"resources":{"type":"pools","ids":[]}}),
+ json!({"actions":["read_pools"],"resources":{"type":"all_pools","ids":null}}),
+ json!({"actions":["read_pools"],"resources":{"type":"all_pools","ids":[]}}),
+ json!({"actions":["read_pools"],"resources":{"type":"all_pools","ignored":true}}),
+ json!({"actions":[{"read_pools":null}],"resources":{"type":"all_pools"}}),
+ json!({"actions":["admin"],"resources":{"type":"all_pools"}}),
+ json!({"actions":["read_pools"],"resources":{"type":"all_pools"},"admin":true}),
+ json!([{"type":"all_pools"},["read_pools"]]),
+ json!({"actions":vec!["read_pools";7],"resources":{"type":"all_pools"}}),
+ ] {
+ assert!(serde_json::from_value::<StockGrantScope>(invalid).is_err());
+ }
+ let mut excessive = valid;
+ excessive["resources"]["ids"] = json!(
+ (0..65)
+ .map(|n| format!("{n:02x}").repeat(32))
+ .collect::<Vec<_>>()
+ );
+ assert!(serde_json::from_value::<StockGrantScope>(excessive).is_err());
+}
+
+#[cfg(feature = "protected_outbox")]
+#[test]
+fn seller_namespace_selection_excludes_only_the_caller_grant_without_minting_permission() {
+ use radroots_storage::workspace::seller_stock::{SellerAuthoritySelection, SellerStockConfig};
+ let (original, proof, record) = SellerStockConfig::new(
+ key(),
+ key(),
+ "namespace-owner",
+ UnixSeconds::new(200).unwrap(),
+ )
+ .unwrap()
+ .enroll(
+ UnixSeconds::new(100).unwrap(),
+ WorkspaceId::from_bytes([1; 32]),
+ ExecutorId::from_bytes([2; 32]),
+ GrantId::from_bytes([3; 32]),
+ AttachmentProof::from_protected_input(&[7; 32]).unwrap(),
+ )
+ .unwrap();
+ let selected = SellerAuthoritySelection::from_attachment(&original);
+ let caller = selected.attachment(GrantId::from_bytes([9; 32])).unwrap();
+ assert_ne!(caller.grant_id(), original.grant_id());
+ assert_eq!(SellerAuthoritySelection::from_attachment(&caller), selected);
+ assert!(selected.matches_attachment(&original));
+ assert!(selected.matches_attachment(&caller));
+ assert!(
+ record
+ .authenticate(&original, &proof, UnixSeconds::new(100).unwrap())
+ .is_ok()
+ );
+ assert!(
+ record
+ .authenticate(&caller, &proof, UnixSeconds::new(100).unwrap())
+ .is_err()
+ );
+ assert_eq!(selected.workspace_id(), original.workspace_id());
+ assert_eq!(selected.authority(), original.authority());
+ assert_eq!(selected.participant(), original.participant());
+ assert_eq!(selected.endpoint(), original.endpoint());
+ assert_eq!(selected.endpoint_identity(), original.endpoint_identity());
+ assert_eq!(selected.checkpoint(), original.checkpoint());
+ assert_eq!(selected.route_digest(), original.route_digest());
+ assert_eq!(
+ format!("{selected:?}"),
+ "SellerAuthoritySelection(<untrusted descriptor>)"
+ );
+}
+
+#[cfg(all(feature = "protected_outbox", feature = "serde"))]
+#[test]
+fn seller_namespace_selection_is_a_closed_object_and_retains_every_namespace_binding() {
+ use radroots_storage::workspace::seller_stock::SellerAuthoritySelection;
+ use serde_json::json;
+ let original = input();
+ let selection = SellerAuthoritySelection::from_attachment(&original);
+ let value = serde_json::to_value(&selection).unwrap();
+ assert!(value.get("grant_id").is_none());
+ assert_eq!(
+ serde_json::from_value::<SellerAuthoritySelection>(value.clone()).unwrap(),
+ selection
+ );
+ for field in [
+ "workspace_id",
+ "authority",
+ "participant",
+ "endpoint",
+ "endpoint_identity",
+ "checkpoint",
+ "route_digest",
+ ] {
+ let mut changed = value.clone();
+ changed.as_object_mut().unwrap().remove(field);
+ assert!(
+ serde_json::from_value::<SellerAuthoritySelection>(changed).is_err(),
+ "{field}"
+ );
+ }
+ let other_key = "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5";
+ for (path, bad) in [
+ ("/workspace_id", json!("0b".repeat(32))),
+ ("/authority/executor_id", json!("0b".repeat(32))),
+ ("/authority/generation", json!("2")),
+ ("/participant", json!(other_key)),
+ ("/endpoint", json!("local://another-namespace")),
+ ("/endpoint_identity", json!(other_key)),
+ ("/checkpoint/digest", json!("0b".repeat(32))),
+ ("/route_digest", json!("0b".repeat(32))),
+ ] {
+ let mut changed = value.clone();
+ *changed.pointer_mut(path).unwrap() = bad;
+ let changed: SellerAuthoritySelection = serde_json::from_value(changed).unwrap();
+ assert!(!changed.matches_attachment(&original), "{path}");
+ }
+ for bad in [json!(""), json!("x".repeat(2049)), json!("local://bad\n")] {
+ let mut changed = value.clone();
+ changed["endpoint"] = bad;
+ assert!(serde_json::from_value::<SellerAuthoritySelection>(changed).is_err());
+ }
+ let mut changed = value.clone();
+ changed["grant_id"] = json!(null);
+ for bad in [
+ json!(null),
+ json!({"id":"radroots.seller_stock.native_inventory","version":"2"}),
+ json!({"id":"radroots.seller_stock.native_inventory","version":1}),
+ json!(["radroots.seller_stock.native_inventory", "1"]),
+ ] {
+ let mut invalid = value.clone();
+ invalid["capability_contract"] = bad;
+ assert!(serde_json::from_value::<SellerAuthoritySelection>(invalid).is_err());
+ }
+
+ assert!(serde_json::from_value::<SellerAuthoritySelection>(changed).is_err());
+ assert!(
+ serde_json::from_value::<SellerAuthoritySelection>(json!([
+ value["workspace_id"],
+ value["authority"]
+ ]))
+ .is_err()
+ );
+}
fn actor() -> ActorRef {
ActorRef::new(key(), ActorRole::Buyer, None, Some(input().grant_id()))
}
diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs
@@ -709,6 +709,31 @@ fn stock_root_context(
input: &super::AttachmentInput,
version: i64,
) -> Result<EnvelopeContext, WorkspaceError> {
+ if version == 4 {
+ use sha2::{Digest, Sha256};
+ let namespace =
+ radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment(
+ input,
+ );
+ let wire = zeroize::Zeroizing::new(
+ serde_json::to_vec(&namespace).map_err(|_| WorkspaceError::InvalidInput)?,
+ );
+ if wire.len() > PRIVATE_PAYLOAD_MAX_BYTES {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ let mut hash = Sha256::new();
+ hash.update(b"radroots.seller_stock.authority_context.v4\0");
+ hash.update(wire.as_slice());
+ let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
+ return Ok(EnvelopeContext::new(
+ EnvelopePurpose::parse("radroots.seller_stock.authority")
+ .map_err(|_| WorkspaceError::InvalidInput)?,
+ EnvelopeSubject::parse("seller_stock", subject.to_string())
+ .map_err(|_| WorkspaceError::InvalidInput)?,
+ PayloadSchemaId::parse("radroots.seller_stock.authority.v4")
+ .map_err(|_| WorkspaceError::InvalidInput)?,
+ ));
+ }
let schema = match version {
1 => "radroots.seller_stock.authority.v1",
2 => "radroots.seller_stock.authority.v2",
@@ -729,6 +754,14 @@ fn stock_record_context(
) -> Result<EnvelopeContext, WorkspaceError> {
use sha2::{Digest, Sha256};
let (purpose, schema) = match kind {
+ "grant_change" => (
+ "radroots.seller_stock.grant_change",
+ "radroots.seller_stock.grant_change.v1",
+ ),
+ "grant" => (
+ "radroots.seller_stock.grant",
+ "radroots.seller_stock.grant.v2",
+ ),
"pool" => (
"radroots.seller_stock.pool",
"radroots.seller_stock.pool.v1",
@@ -766,9 +799,10 @@ fn stock_record_context_for_catalog(
) -> Result<EnvelopeContext, WorkspaceError> {
let original = stock_record_context(input, kind, id)?;
let schema = match (catalog, kind) {
- (2, _) | (3, "pool") => return Ok(original),
+ (2, _) | (3 | 4, "pool") => return Ok(original),
(3, "operation") => "radroots.seller_stock.operation.v2",
- (3, "movement") => "radroots.seller_stock.movement.v2",
+ (4, "operation") => "radroots.seller_stock.operation.v3",
+ (3 | 4, "movement") => "radroots.seller_stock.movement.v2",
_ => return Err(WorkspaceError::RecoveryRequired),
};
Ok(EnvelopeContext::new(
diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs
@@ -22,7 +22,10 @@ mod recovery;
mod schema;
mod snapshot;
mod stock;
-pub use stock::{SellerStockConfig, StockAuthorityReceipt, StockEnrollment};
+pub use stock::{
+ SellerStockConfig, StockAuthorityReceipt, StockEnrollment, StockGrantEnrollment,
+ StockGrantOutcome, StockGrantReceipt,
+};
mod worker;
#[cfg(test)]
diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs
@@ -5,6 +5,12 @@ use super::{
};
use radroots_domain::{ExecutorId, GrantId, Sequence, TransactionId, WorkspaceId};
pub use radroots_storage::workspace::seller_stock::SellerStockConfig;
+use radroots_storage::workspace::seller_stock::{
+ SellerAuthoritySelection, StockAction, StockAuthorizationRef, StockGrantRecord, StockGrantScope,
+};
+pub(in crate::workspace) mod grants;
+use grants::StockRecord;
+pub use grants::{StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt};
use serde::{Deserialize, Serialize};
use sqlx::{Connection, SqliteConnection};
use std::{
@@ -143,6 +149,7 @@ struct Authority {
transaction: TransactionId,
revocation: Sequence,
inventory: Option<InventoryCheckpoint>,
+ authorization: Option<StockAuthorizationRef>,
}
#[derive(Clone, Copy, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
@@ -175,8 +182,35 @@ struct InventoryAuthorityWire {
revocation: Sequence,
inventory: InventoryCheckpoint,
}
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct AuthorityV4 {
+ version: u8,
+ namespace: SellerAuthoritySelection,
+ administrator: GrantId,
+ transaction: TransactionId,
+ revocation: Sequence,
+ inventory: InventoryCheckpoint,
+ authorization: StockAuthorizationRef,
+}
impl Authority {
fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> {
+ if self.catalog == 4 {
+ let bytes = serde_json::to_vec(&AuthorityV4 {
+ version: 4,
+ namespace: SellerAuthoritySelection::from_attachment(&self.input),
+ administrator: self.input.grant_id(),
+ transaction: self.transaction,
+ revocation: self.revocation,
+ inventory: self.inventory.ok_or(WorkspaceError::RecoveryRequired)?,
+ authorization: self.authorization.ok_or(WorkspaceError::RecoveryRequired)?,
+ })
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ if bytes.len() > 16 * 1024 {
+ return Err(WorkspaceError::Capacity);
+ }
+ return Ok(zeroize::Zeroizing::new(bytes));
+ }
let bytes = match self.inventory {
None => serde_json::to_vec(&AuthorityV1 {
version: 1,
@@ -208,6 +242,7 @@ impl Authority {
transaction: v.transaction,
revocation: v.revocation,
inventory: None,
+ authorization: None,
}
}
2 | 3 => {
@@ -223,6 +258,24 @@ impl Authority {
transaction: v.transaction,
revocation: v.revocation,
inventory: Some(v.inventory),
+ authorization: None,
+ }
+ }
+ 4 => {
+ let v: AuthorityV4 = closed_record(bytes)?;
+ if v.version != 4
+ || v.authorization.generation() != v.revocation
+ || (v.inventory.revision.get() == 0) != v.inventory.head.is_none()
+ {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ Self {
+ catalog,
+ input: v.namespace.attachment(v.administrator)?,
+ transaction: v.transaction,
+ revocation: v.revocation,
+ inventory: Some(v.inventory),
+ authorization: Some(v.authorization),
}
}
_ => return Err(WorkspaceError::RecoveryRequired),
@@ -253,8 +306,9 @@ pub(super) async fn initialize(
) -> Result<(), WorkspaceError> {
namespace.validate()?;
if let Some(initial) = initial {
- let authority = Authority {
+ let mut authority = Authority {
catalog: schema::CURRENT,
+ authorization: None,
input: input.clone(),
transaction: initial.transaction,
revocation: Sequence::new(1).map_err(|_| WorkspaceError::InvalidInput)?,
@@ -265,13 +319,20 @@ pub(super) async fn initialize(
movements: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?,
}),
};
+ let initial_record = StockGrantRecord::from_enrollment(initial.grant)?;
+ let grant = crypto
+ .seal_stock_record(
+ input,
+ "grant",
+ input.grant_id().as_bytes(),
+ &initial_record.encode()?,
+ )
+ .await?;
+ authority.authorization = Some(grants::single_state(input.grant_id(), &grant)?);
let clear = authority.encode()?;
let root = crypto
.seal_stock_root(input, authority.version(), &clear)
.await?;
- let grant = crypto
- .seal_stock(input, false, &initial.grant.encode()?)
- .await?;
let now = initial.clock.now()?;
if now.get() == 0 {
return Err(WorkspaceError::Unavailable);
@@ -298,7 +359,7 @@ pub(super) async fn initialize(
.await
.map_err(|_| WorkspaceError::StorageFailure)?;
}
- sqlx::query("PRAGMA user_version=3")
+ sqlx::query("PRAGMA user_version=4")
.execute(&mut *tx)
.await
.map_err(|_| WorkspaceError::StorageFailure)?;
@@ -335,7 +396,7 @@ async fn read(
connection: &mut SqliteConnection,
input: &AttachmentInput,
crypto: &WorkspaceCrypto,
-) -> Result<(Authority, GrantRecord, Vec<u8>, Vec<u8>), WorkspaceError> {
+) -> Result<(Authority, StockRecord, Vec<u8>, Vec<u8>), WorkspaceError> {
// Bound in SQL before materializing attacker-controlled protected payloads.
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)?;
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)?;
@@ -345,15 +406,40 @@ async fn read(
.map_err(|_| WorkspaceError::RecoveryRequired)?;
let clear = crypto.open_stock_root(input, catalog, &root).await?;
let authority = clear.expose_secret(|bytes| Authority::decode(bytes, catalog))?;
- if authority.input != *input || authority.revocation.get() == 0 {
+ if (if catalog == 4 {
+ !SellerAuthoritySelection::from_attachment(&authority.input).matches_attachment(input)
+ } else {
+ authority.input != *input
+ }) || authority.revocation.get() == 0
+ {
return Err(WorkspaceError::WrongNamespace);
}
- let clear = crypto.open_stock(input, false, &grant).await?;
- let record = clear.expose_secret(GrantRecord::decode)?;
- // Validate the protected scope without inventing possession of its credential.
- if record.scope() != WorkspaceScope::SellerStockOwner {
- return Err(WorkspaceError::RecoveryRequired);
- }
+ let record = if catalog == 4 {
+ grants::check_state(
+ connection,
+ authority
+ .authorization
+ .ok_or(WorkspaceError::RecoveryRequired)?,
+ )
+ .await?;
+ let clear = crypto
+ .open_stock_record(input, "grant", input.grant_id().as_bytes(), &grant)
+ .await?;
+ let record = clear.expose_secret(StockGrantRecord::decode)?;
+ if !record.belongs_to(&SellerAuthoritySelection::from_attachment(input))?
+ || record.administrator() != (input.grant_id() == authority.input.grant_id())
+ {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ StockRecord::Scoped(record)
+ } else {
+ let clear = crypto.open_stock(input, false, &grant).await?;
+ let record = clear.expose_secret(GrantRecord::decode)?;
+ if record.scope() != WorkspaceScope::SellerStockOwner {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ StockRecord::Legacy(record)
+ };
if let Some(checkpoint) = authority.inventory {
inventory::check_head(connection, checkpoint).await?;
}
@@ -369,7 +455,10 @@ pub(super) async fn authenticate(
proof: &AttachmentProof,
) -> Result<(StockAuthorityReceipt, WorkspaceBinding), WorkspaceError> {
namespace.validate()?;
- let (authority, record, root, grant) = read(connection, expected, crypto).await?;
+ if !SellerAuthoritySelection::from_attachment(expected).matches_attachment(selected) {
+ return Err(WorkspaceError::WrongNamespace);
+ }
+ let (authority, record, root, grant) = read(connection, selected, crypto).await?;
record.authenticate(selected, proof, clock.now()?)?;
let mut tx = connection
.begin_with("BEGIN IMMEDIATE")
@@ -377,7 +466,10 @@ pub(super) async fn authenticate(
.map_err(|_| WorkspaceError::StorageFailure)?;
let checked = async {
namespace.validate()?;
- unchanged(&mut tx, expected, authority.version(), &root, &grant).await?;
+ unchanged(&mut tx, selected, authority.version(), &root, &grant).await?;
+ if let Some(state) = authority.authorization {
+ grants::check_state(&mut tx, state).await?;
+ }
record.authenticate(selected, proof, clock.now()?)
}
.await;
@@ -385,6 +477,11 @@ pub(super) async fn authenticate(
.await
.map_err(|_| WorkspaceError::CommitUnknown)?;
let binding = checked?;
+ let binding = if let Some(state) = authority.authorization {
+ binding.with_stock_authorization(state)?
+ } else {
+ binding
+ };
if binding.scope() != WorkspaceScope::SellerStockOwner {
return Err(WorkspaceError::RecoveryRequired);
}
@@ -402,6 +499,13 @@ pub(super) async fn authenticate(
v.revision,
v.head,
)
+ .map(|checkpoint| {
+ if let Some(state) = authority.authorization {
+ checkpoint.with_authorization(state)
+ } else {
+ checkpoint
+ }
+ })
})
.transpose()?,
},
@@ -418,8 +522,14 @@ pub(super) async fn revoke(
proof: &AttachmentProof,
) -> Result<(), WorkspaceError> {
namespace.validate()?;
+ if !SellerAuthoritySelection::from_attachment(expected).matches_attachment(selected) {
+ return Err(WorkspaceError::WrongNamespace);
+ }
let (mut authority, mut record, old_root, old_grant) =
- read(connection, expected, crypto).await?;
+ read(connection, selected, crypto).await?;
+ if authority.catalog == 4 {
+ return Err(WorkspaceError::Unauthorized);
+ }
let expiry = record
.authenticate(selected, proof, clock.now()?)?
.expires_at();
diff --git a/crates/storage_sqlite/src/workspace/stock/grants.rs b/crates/storage_sqlite/src/workspace/stock/grants.rs
@@ -0,0 +1,577 @@
+//! Protected grant-set updates on the existing stock connection owner.
+use super::*;
+use radroots_domain::{CheckpointDigest, PoolId};
+use radroots_storage::command::OperationError;
+use sha2::{Digest, Sha256};
+use sqlx::Row;
+
+pub(super) enum StockRecord {
+ Legacy(GrantRecord),
+ Scoped(StockGrantRecord),
+}
+impl StockRecord {
+ pub(super) fn authenticate(
+ &self,
+ input: &AttachmentInput,
+ proof: &AttachmentProof,
+ now: radroots_domain::UnixSeconds,
+ ) -> Result<WorkspaceBinding, WorkspaceError> {
+ match self {
+ Self::Legacy(v) => v.authenticate(input, proof, now),
+ Self::Scoped(v) => v.authenticate(input, proof, now),
+ }
+ }
+ pub(super) fn authenticate_retained_capture(
+ &self,
+ input: &AttachmentInput,
+ proof: &AttachmentProof,
+ ) -> Result<(), WorkspaceError> {
+ match self {
+ Self::Legacy(v) => v.authenticate_retained_capture(input, proof),
+ Self::Scoped(v) => v.authenticate_retained_capture(input, proof),
+ }
+ }
+ pub(super) fn revoke(&mut self) -> Result<(), WorkspaceError> {
+ match self {
+ Self::Legacy(v) => v.revoke(),
+ Self::Scoped(v) => v.revoke(),
+ }
+ }
+ pub(super) fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> {
+ match self {
+ Self::Legacy(v) => v.encode(),
+ Self::Scoped(v) => v.encode(),
+ }
+ }
+ pub(super) fn allows_action(&self, action: StockAction) -> bool {
+ match self {
+ Self::Legacy(_) => true,
+ Self::Scoped(v) => v.permissions().allows_action(action),
+ }
+ }
+ pub(super) fn require(&self, action: StockAction, pool: PoolId) -> Result<(), OperationError> {
+ if match self {
+ Self::Legacy(_) => true,
+ Self::Scoped(v) => v.permissions().allows(action, pool),
+ } {
+ Ok(())
+ } else {
+ Err(OperationError::Unauthorized)
+ }
+ }
+ fn administrator(&self) -> bool {
+ matches!(self, Self::Scoped(v) if v.administrator())
+ }
+}
+
+fn state_hash() -> Sha256 {
+ let mut h = Sha256::new();
+ h.update(b"radroots.seller_stock.grant_set.v1\0");
+ h
+}
+fn hash_row(hash: &mut Sha256, id: &[u8], protected: &[u8]) {
+ hash.update(id);
+ hash.update((protected.len() as u64).to_be_bytes());
+ hash.update(protected);
+}
+pub(super) fn single_state(
+ id: GrantId,
+ protected: &[u8],
+) -> Result<StockAuthorizationRef, WorkspaceError> {
+ let mut hash = state_hash();
+ hash_row(&mut hash, id.as_bytes(), protected);
+ StockAuthorizationRef::from_host_metadata(
+ Sequence::new(1).map_err(|_| WorkspaceError::Capacity)?,
+ CheckpointDigest::from_bytes(hash.finalize().into()),
+ )
+}
+async fn snapshot(
+ connection: &mut SqliteConnection,
+) -> Result<Vec<(GrantId, Vec<u8>)>, WorkspaceError> {
+ // The count is checked before materializing bounded rows. Revoked grants
+ // remain retained; exhaustion requires an explicit successor contract.
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grants")
+ .fetch_one(&mut *connection)
+ .await
+ .map_err(|_| WorkspaceError::RecoveryRequired)?;
+ if !(1..=64).contains(&count) {
+ return Err(WorkspaceError::Capacity);
+ }
+ let rows=sqlx::query("SELECT grant_id, CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_grants ORDER BY grant_id LIMIT 65").fetch_all(connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?;
+ if rows.len() != count as usize {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ rows.into_iter()
+ .map(|row| {
+ let id: Vec<u8> = row
+ .try_get(0)
+ .map_err(|_| WorkspaceError::RecoveryRequired)?;
+ let protected: Vec<u8> = row
+ .try_get::<Option<Vec<u8>>, _>(1)
+ .map_err(|_| WorkspaceError::RecoveryRequired)?
+ .ok_or(WorkspaceError::RecoveryRequired)?;
+ Ok((
+ GrantId::from_bytes(
+ id.try_into()
+ .map_err(|_| WorkspaceError::RecoveryRequired)?,
+ ),
+ protected,
+ ))
+ })
+ .collect()
+}
+fn state(
+ generation: Sequence,
+ rows: &[(GrantId, Vec<u8>)],
+) -> Result<StockAuthorizationRef, WorkspaceError> {
+ let mut hash = state_hash();
+ for (id, protected) in rows {
+ hash_row(&mut hash, id.as_bytes(), protected);
+ }
+ StockAuthorizationRef::from_host_metadata(
+ generation,
+ CheckpointDigest::from_bytes(hash.finalize().into()),
+ )
+}
+pub(super) async fn check_state(
+ connection: &mut SqliteConnection,
+ expected: StockAuthorizationRef,
+) -> Result<(), WorkspaceError> {
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grant_changes")
+ .fetch_one(&mut *connection)
+ .await
+ .map_err(|_| WorkspaceError::RecoveryRequired)?;
+ let maximum: i64 =
+ sqlx::query_scalar("SELECT coalesce(max(revision),1) FROM stock_grant_changes")
+ .fetch_one(&mut *connection)
+ .await
+ .map_err(|_| WorkspaceError::RecoveryRequired)?;
+ if count != expected.generation().get() as i64 - 1
+ || maximum != expected.generation().get() as i64
+ {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ if state(expected.generation(), &snapshot(connection).await?)? != expected {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ Ok(())
+}
+
+/// Prepared before IO; the original credential and transaction ID survive a
+/// lost observer. This value creates no grant until an administrator commits it.
+pub struct StockGrantEnrollment {
+ input: AttachmentInput,
+ proof: AttachmentProof,
+ record: StockGrantRecord,
+ transaction: TransactionId,
+}
+impl StockGrantEnrollment {
+ pub fn prepare(
+ namespace: &SellerAuthoritySelection,
+ principal: String,
+ expires_at: radroots_domain::UnixSeconds,
+ permissions: StockGrantScope,
+ ) -> Result<Self, WorkspaceError> {
+ let input = namespace.attachment(GrantId::from_bytes(super::super::random()?))?;
+ let secret = zeroize::Zeroizing::new(super::super::random()?);
+ let proof = AttachmentProof::from_protected_input(secret.as_ref())?;
+ let record =
+ StockGrantRecord::new(input.clone(), principal, expires_at, permissions, &proof)?;
+ Ok(Self {
+ input,
+ proof,
+ record,
+ transaction: TransactionId::from_bytes(super::super::random()?),
+ })
+ }
+ pub fn input(&self) -> &AttachmentInput {
+ &self.input
+ }
+ pub fn proof(&self) -> &AttachmentProof {
+ &self.proof
+ }
+ pub const fn transaction_id(&self) -> TransactionId {
+ self.transaction
+ }
+}
+impl std::fmt::Debug for StockGrantEnrollment {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str("StockGrantEnrollment(<redacted>)")
+ }
+}
+
+/// An actual confirmed grant-set mutation, suitable for independent retention.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct StockGrantReceipt {
+ pub(super) transaction: TransactionId,
+ pub(super) grant: GrantId,
+ pub(super) authorization: StockAuthorizationRef,
+}
+impl StockGrantReceipt {
+ pub const fn transaction_id(&self) -> TransactionId {
+ self.transaction
+ }
+ pub const fn grant_id(&self) -> GrantId {
+ self.grant
+ }
+ pub const fn authorization(&self) -> StockAuthorizationRef {
+ self.authorization
+ }
+}
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum StockGrantOutcome {
+ Committed(StockGrantReceipt),
+ Unknown(TransactionId),
+}
+
+pub(in crate::workspace) struct Change {
+ pub caller: WorkspaceBinding,
+ pub minimum: radroots_storage::inventory::InventoryCheckpointRef,
+ pub transaction: TransactionId,
+ pub target: GrantId,
+ pub addition: Option<zeroize::Zeroizing<Vec<u8>>>,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ChangeWire {
+ version: u8,
+ transaction: TransactionId,
+ target: GrantId,
+ caller: GrantId,
+ digest: CheckpointDigest,
+ prior_authorization: StockAuthorizationRef,
+ authorization: StockAuthorizationRef,
+}
+fn change_digest(change: &Change) -> Result<CheckpointDigest, WorkspaceError> {
+ let mut hash = Sha256::new();
+ hash.update(b"radroots.seller_stock.grant_change.v1\0");
+ let namespace = SellerAuthoritySelection::from_attachment(change.caller.input());
+ let clear = zeroize::Zeroizing::new(
+ serde_json::to_vec(&namespace).map_err(|_| WorkspaceError::InvalidInput)?,
+ );
+ hash.update(clear.as_slice());
+ hash.update(change.caller.input().grant_id().as_bytes());
+ hash.update(change.transaction.as_bytes());
+ hash.update(change.target.as_bytes());
+ hash.update([u8::from(change.addition.is_some())]);
+ if let Some(clear) = &change.addition {
+ hash.update(clear.as_slice());
+ }
+ Ok(CheckpointDigest::from_bytes(hash.finalize().into()))
+}
+
+impl NativeWorkspace {
+ pub async fn enroll_stock_grant(
+ &self,
+ caller: WorkspaceBinding,
+ minimum: radroots_storage::inventory::InventoryCheckpointRef,
+ proof: &AttachmentProof,
+ enrollment: &StockGrantEnrollment,
+ ) -> Result<StockGrantOutcome, WorkspaceError> {
+ let addition = enrollment.record.encode()?;
+ let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?;
+ self.worker
+ .change_stock_grant(
+ Change {
+ caller,
+ minimum,
+ transaction: enrollment.transaction,
+ target: enrollment.input.grant_id(),
+ addition: Some(addition),
+ },
+ proof,
+ )
+ .await
+ }
+ /// The caller prepares and retains this transaction ID before submission.
+ pub async fn revoke_stock_grant(
+ &self,
+ caller: WorkspaceBinding,
+ minimum: radroots_storage::inventory::InventoryCheckpointRef,
+ proof: &AttachmentProof,
+ transaction: TransactionId,
+ target: GrantId,
+ ) -> Result<StockGrantOutcome, WorkspaceError> {
+ let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?;
+ self.worker
+ .change_stock_grant(
+ Change {
+ caller,
+ minimum,
+ transaction,
+ target,
+ addition: None,
+ },
+ proof,
+ )
+ .await
+ }
+}
+
+pub(in crate::workspace) async fn change(
+ turn: &mut inventory::Turn<'_>,
+ change: Change,
+ proof: AttachmentProof,
+) -> Result<StockGrantOutcome, WorkspaceError> {
+ if *turn.uncertain {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ turn.namespace.validate()?;
+ if !SellerAuthoritySelection::from_attachment(turn.selected)
+ .matches_attachment(change.caller.input())
+ {
+ return Err(WorkspaceError::WrongNamespace);
+ }
+ let (mut authority, record, old_root, old_grant) =
+ super::read(turn.connection, change.caller.input(), turn.crypto).await?;
+ if authority.catalog != 4 {
+ return Err(WorkspaceError::Unauthorized);
+ }
+ let current = record.authenticate(change.caller.input(), &proof, turn.clock.now()?)?;
+ if current.observed_at() < change.caller.observed_at() {
+ return Err(WorkspaceError::Unavailable);
+ }
+ radroots_storage::command::protected::same_binding(&change.caller, ¤t)
+ .map_err(|_| WorkspaceError::Unauthorized)?;
+ if !record.administrator() {
+ return Err(WorkspaceError::Unauthorized);
+ }
+ let authorization = authority
+ .authorization
+ .ok_or(WorkspaceError::RecoveryRequired)?;
+ // Existing protected ancestry is checked outside the SQL lock and its exact
+ // row witness is rechecked inside it, alongside the grant-set fingerprint.
+ let ancestry = inventory::grant_minimum(
+ turn.connection,
+ turn.selected,
+ turn.crypto,
+ ¤t,
+ authority
+ .inventory
+ .ok_or(WorkspaceError::RecoveryRequired)?,
+ change.minimum,
+ )
+ .await?;
+ let digest = change_digest(&change)?;
+ let existing:Option<Vec<u8>>=sqlx::query_scalar("SELECT protected FROM stock_grant_changes WHERE transaction_id=? AND length(protected) BETWEEN 1 AND 262144").bind(change.transaction.as_bytes().as_slice()).fetch_optional(&mut *turn.connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?;
+ if let Some(protected) = existing {
+ let clear = turn
+ .crypto
+ .open_stock_record(
+ turn.selected,
+ "grant_change",
+ change.transaction.as_bytes(),
+ &protected,
+ )
+ .await?;
+ let retained: ChangeWire = clear.expose_secret(|bytes| super::closed_record(bytes))?;
+ if retained.version != 1
+ || retained.transaction != change.transaction
+ || retained.target != change.target
+ || retained.caller != current.input().grant_id()
+ || retained.digest != digest
+ || (change.minimum.authorization() != Some(authorization)
+ && change.minimum.authorization() != Some(retained.prior_authorization))
+ || retained.authorization.generation().get() > authorization.generation().get()
+ {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ let mut tx = turn
+ .connection
+ .begin_with("BEGIN IMMEDIATE")
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ let checked: Result<(), WorkspaceError> = async {
+ super::unchanged(&mut tx, current.input(), 4, &old_root, &old_grant).await?;
+ check_state(&mut tx, authorization).await?;
+ ancestry
+ .confirm(&mut tx)
+ .await
+ .map_err(|_| WorkspaceError::RecoveryRequired)?;
+ let checked = record.authenticate(current.input(), &proof, turn.clock.now()?)?;
+ if checked.observed_at() < current.observed_at() {
+ return Err(WorkspaceError::Unavailable);
+ }
+ let matched: i64 = sqlx::query_scalar(
+ "SELECT count(*) FROM stock_grant_changes WHERE transaction_id=? AND protected=?",
+ )
+ .bind(change.transaction.as_bytes().as_slice())
+ .bind(&protected)
+ .fetch_one(&mut *tx)
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ if matched != 1 {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ Ok(())
+ }
+ .await;
+ if tx.rollback().await.is_err() {
+ *turn.uncertain = true;
+ return Ok(StockGrantOutcome::Unknown(change.transaction));
+ }
+ checked?;
+ return Ok(StockGrantOutcome::Committed(StockGrantReceipt {
+ transaction: retained.transaction,
+ grant: retained.target,
+ authorization: retained.authorization,
+ }));
+ }
+ if change.minimum.authorization() != Some(authorization) {
+ return Err(WorkspaceError::StaleCheckpoint);
+ }
+ let mut rows = snapshot(turn.connection).await?;
+ let position = rows.binary_search_by_key(&change.target, |v| v.0);
+ let protected = if let Some(clear) = &change.addition {
+ if position.is_ok() {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ if rows.len() >= 64 {
+ return Err(WorkspaceError::Capacity);
+ }
+ let new = StockGrantRecord::decode(clear)?;
+ if new.input().grant_id() != change.target || new.expires_at() <= turn.clock.now()? {
+ return Err(WorkspaceError::InvalidInput);
+ }
+ if new.administrator()
+ || !new.belongs_to(&SellerAuthoritySelection::from_attachment(turn.selected))?
+ {
+ return Err(WorkspaceError::Unauthorized);
+ }
+ turn.crypto
+ .seal_stock_record(turn.selected, "grant", change.target.as_bytes(), clear)
+ .await?
+ } else {
+ let index = position.map_err(|_| WorkspaceError::WrongNamespace)?;
+ let input =
+ SellerAuthoritySelection::from_attachment(turn.selected).attachment(change.target)?;
+ let clear = turn
+ .crypto
+ .open_stock_record(&input, "grant", change.target.as_bytes(), &rows[index].1)
+ .await?;
+ let mut target = clear.expose_secret(StockGrantRecord::decode)?;
+ target.revoke()?;
+ turn.crypto
+ .seal_stock_record(&input, "grant", change.target.as_bytes(), &target.encode()?)
+ .await?
+ };
+ match position {
+ Ok(index) => rows[index].1 = protected.clone(),
+ Err(index) => rows.insert(index, (change.target, protected.clone())),
+ }
+ authority.revocation = Sequence::new(
+ authority
+ .revocation
+ .get()
+ .checked_add(1)
+ .ok_or(WorkspaceError::Capacity)?,
+ )
+ .map_err(|_| WorkspaceError::Capacity)?;
+ let next = state(authority.revocation, &rows)?;
+ authority.authorization = Some(next);
+ let root = turn
+ .crypto
+ .seal_stock_root(turn.selected, 4, &authority.encode()?)
+ .await?;
+ let retained = ChangeWire {
+ version: 1,
+ transaction: change.transaction,
+ target: change.target,
+ caller: current.input().grant_id(),
+ digest,
+ prior_authorization: authorization,
+ authorization: next,
+ };
+ let clear = zeroize::Zeroizing::new(
+ serde_json::to_vec(&retained).map_err(|_| WorkspaceError::StorageFailure)?,
+ );
+ let receipt = turn
+ .crypto
+ .seal_stock_record(
+ turn.selected,
+ "grant_change",
+ change.transaction.as_bytes(),
+ &clear,
+ )
+ .await?;
+ let mut tx = turn
+ .connection
+ .begin_with("BEGIN IMMEDIATE")
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ let changed: Result<(), WorkspaceError> = async {
+ turn.namespace.validate()?;
+ super::unchanged(&mut tx, current.input(), 4, &old_root, &old_grant).await?;
+ check_state(&mut tx, authorization).await?;
+ ancestry
+ .confirm(&mut tx)
+ .await
+ .map_err(|_| WorkspaceError::RecoveryRequired)?;
+ let now = turn.clock.now()?;
+ record.authenticate(current.input(), &proof, now)?;
+ if now < current.observed_at() {
+ return Err(WorkspaceError::Unavailable);
+ }
+ if let Some(clear) = &change.addition
+ && StockGrantRecord::decode(clear)?.expires_at() <= now
+ {
+ return Err(WorkspaceError::GrantExpired);
+ }
+ if position.is_ok() {
+ let result = sqlx::query("UPDATE stock_grants SET protected=? WHERE grant_id=?")
+ .bind(&protected)
+ .bind(change.target.as_bytes().as_slice())
+ .execute(&mut *tx)
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ if result.rows_affected() != 1 {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ } else {
+ sqlx::query("INSERT INTO stock_grants(grant_id,protected) VALUES(?,?)")
+ .bind(change.target.as_bytes().as_slice())
+ .bind(&protected)
+ .execute(&mut *tx)
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ }
+ sqlx::query(
+ "INSERT INTO stock_grant_changes(transaction_id,revision,protected) VALUES(?,?,?)",
+ )
+ .bind(change.transaction.as_bytes().as_slice())
+ .bind(next.generation().get() as i64)
+ .bind(receipt)
+ .execute(&mut *tx)
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ let result =
+ sqlx::query("UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?")
+ .bind(root)
+ .bind(&old_root)
+ .execute(&mut *tx)
+ .await
+ .map_err(|_| WorkspaceError::StorageFailure)?;
+ if result.rows_affected() != 1 {
+ return Err(WorkspaceError::RecoveryRequired);
+ }
+ turn.namespace.validate()?;
+ Ok(())
+ }
+ .await;
+ if let Err(error) = changed {
+ if tx.rollback().await.is_err() {
+ *turn.uncertain = true;
+ return Ok(StockGrantOutcome::Unknown(change.transaction));
+ }
+ return Err(error);
+ }
+ if tx.commit().await.is_err() {
+ *turn.uncertain = true;
+ return Ok(StockGrantOutcome::Unknown(change.transaction));
+ }
+ Ok(StockGrantOutcome::Committed(StockGrantReceipt {
+ transaction: change.transaction,
+ grant: change.target,
+ authorization: next,
+ }))
+}
diff --git a/crates/storage_sqlite/src/workspace/stock/inventory.rs b/crates/storage_sqlite/src/workspace/stock/inventory.rs
@@ -4,7 +4,19 @@ mod codec;
mod plan;
use super::*;
use checkpoint::{MinimumProof, authenticate_minimum};
-use codec::{Movement, MovementKind, OperationWire, decode_operation};
+pub(super) async fn grant_minimum(
+ connection: &mut SqliteConnection,
+ input: &AttachmentInput,
+ crypto: &WorkspaceCrypto,
+ binding: &WorkspaceBinding,
+ current: InventoryCheckpoint,
+ minimum: radroots_storage::inventory::InventoryCheckpointRef,
+) -> Result<MinimumProof, WorkspaceError> {
+ authenticate_minimum(connection, input, crypto, binding, current, minimum)
+ .await
+ .map_err(|_| WorkspaceError::RecoveryRequired)
+}
+use codec::{Movement, MovementKind, OperationWire, decode_operation, encode_operation};
use plan::{plan_effect, record_version};
use radroots_domain::{
CheckpointDigest, CommandDigest, OperationId, PoolId, UnixSeconds,
@@ -54,7 +66,7 @@ pub(super) async fn check_head(
}
struct Access {
authority: Authority,
- record: GrantRecord,
+ record: StockRecord,
root: Vec<u8>,
grant: Vec<u8>,
current: WorkspaceBinding,
@@ -79,13 +91,26 @@ impl Turn<'_> {
return Err(OperationError::RecoveryRequired);
}
self.namespace.validate()?;
+ if !SellerAuthoritySelection::from_attachment(self.selected)
+ .matches_attachment(binding.input())
+ {
+ return Err(OperationError::Unauthorized);
+ }
let (authority, record, root, grant) =
- super::read(self.connection, self.selected, self.crypto).await?;
+ super::read(self.connection, binding.input(), self.crypto).await?;
let current = record.authenticate(binding.input(), proof, self.clock.now()?)?;
if current.scope() != WorkspaceScope::SellerStockOwner {
return Err(OperationError::Unauthorized);
}
same_binding(binding, ¤t)?;
+ if authority.authorization != minimum.authorization() {
+ return Err(WorkspaceError::StaleCheckpoint.into());
+ }
+ let current = if let Some(state) = authority.authorization {
+ current.with_stock_authorization(state)?
+ } else {
+ current
+ };
if authority.inventory.is_none() {
return Err(OperationError::UnsupportedOperation);
}
@@ -119,6 +144,9 @@ impl Turn<'_> {
let mut access = self
.access(request.binding(), request.minimum_checkpoint(), &proof)
.await?;
+ access
+ .record
+ .require(StockAction::ReadOperations, request.command().pool_id())?;
let context = request.command().context();
let operation = context.operation_id();
let digest = request.command().digest();
@@ -139,6 +167,31 @@ impl Turn<'_> {
.await?;
return Ok(InventoryOutcome::Committed(Box::new(retained.receipt)));
}
+ if request.replay_only() {
+ return Err(OperationError::RecoveryRequired);
+ }
+ access.record.require(
+ match request.command().kind() {
+ radroots_storage::inventory::InventoryCommandKind::CreatePool => {
+ StockAction::CreatePool
+ }
+ radroots_storage::inventory::InventoryCommandKind::AddStock => {
+ StockAction::AddStock
+ }
+ radroots_storage::inventory::InventoryCommandKind::RemoveStock => {
+ StockAction::RemoveStock
+ }
+ radroots_storage::inventory::InventoryCommandKind::SpoilStock => {
+ StockAction::SpoilStock
+ }
+ },
+ request.command().pool_id(),
+ )?;
+ // An original captured command may be replayed under a replacement grant,
+ // but a new effect must have been captured under this current grant.
+ if request.command().context().actor() != access.current.actor() {
+ return Err(OperationError::Unauthorized);
+ }
if access.current.observed_at() < request.binding().observed_at() {
return Err(WorkspaceError::Unavailable.into());
}
@@ -209,7 +262,8 @@ impl Turn<'_> {
self.selected.authority(),
revision,
Some(head),
- )?,
+ )?
+ .with_optional_authorization(access.authority.authorization),
)?;
let protected_pool = self
.crypto
@@ -255,25 +309,29 @@ impl Turn<'_> {
"operation",
operation.as_bytes(),
catalog,
- &encode(&OperationWire {
- version: record_version(catalog)?,
- before: if catalog == 3 { Some(before) } else { None },
- selection: request.binding().input(),
- scope: request.binding().scope(),
- principal: request.binding().principal_id(),
- grant_revision: request.binding().grant_revision(),
- grant_expires_at: request.binding().expires_at(),
- observed_at: request.binding().observed_at(),
- minimum_revision: request.minimum_checkpoint().revision(),
- minimum_head: request.minimum_checkpoint().head(),
- transaction,
- revision,
- previous_head: checkpoint.head,
- head,
- command,
- pool,
- movement,
- })?,
+ &encode_operation(
+ &OperationWire {
+ version: record_version(catalog)?,
+ before: if catalog >= 3 { Some(before) } else { None },
+ selection: request.binding().input(),
+ scope: request.binding().scope(),
+ principal: request.binding().principal_id(),
+ grant_revision: request.binding().grant_revision(),
+ grant_expires_at: request.binding().expires_at(),
+ observed_at: request.binding().observed_at(),
+ minimum_revision: request.minimum_checkpoint().revision(),
+ minimum_head: request.minimum_checkpoint().head(),
+ transaction,
+ revision,
+ previous_head: checkpoint.head,
+ head,
+ command,
+ pool,
+ movement,
+ },
+ catalog,
+ access.authority.authorization,
+ )?,
)
.await?;
access.authority.inventory = Some(InventoryCheckpoint {
@@ -307,7 +365,8 @@ impl Turn<'_> {
.await
.map_err(|_| OperationError::StorageFailure)?;
let changed:Result<(),OperationError>=async {
- super::unchanged(&mut tx,self.selected,access.authority.version(),&access.root,&access.grant).await?;
+ super::unchanged(&mut tx,access.current.input(),access.authority.version(),&access.root,&access.grant).await?;
+ if let Some(state)=access.authority.authorization { grants::check_state(&mut tx,state).await?; }
check_head(&mut tx,checkpoint).await?;
access.minimum_proof.confirm(&mut tx).await?;
let current=access.record.authenticate(request.binding().input(),&proof,self.clock.now()?)?;
@@ -315,7 +374,7 @@ impl Turn<'_> {
if current.observed_at()<access.current.observed_at() {return Err(WorkspaceError::Unavailable.into());}
if current.observed_at()>=context.not_after() {return Err(OperationError::DeadlineExceeded);}
self.namespace.validate()?;
- let absent:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND grant_id=? AND operation_id=?").bind(request.binding().actor().participant().as_bytes().as_slice()).bind(request.binding().input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
+ let absent:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND operation_id=?").bind(request.binding().actor().participant().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
if absent!=0 {return Err(OperationError::StaleState);}
if let Some(before)=before {
let original=existing.as_ref().ok_or(OperationError::RecoveryRequired)?;
@@ -364,17 +423,18 @@ impl Turn<'_> {
.map_err(|_| OperationError::StorageFailure)?;
let checked:Result<(),OperationError>=async {
self.namespace.validate()?;
- super::unchanged(&mut tx,self.selected,access.authority.version(),&access.root,&access.grant).await?;
+ super::unchanged(&mut tx,access.current.input(),access.authority.version(),&access.root,&access.grant).await?;
+ if let Some(state)=access.authority.authorization { grants::check_state(&mut tx,state).await?; }
check_head(&mut tx,access.authority.inventory.ok_or(OperationError::UnsupportedOperation)?).await?;
access.minimum_proof.confirm(&mut tx).await?;
let current=access.record.authenticate(access.current.input(),proof,self.clock.now()?)?;
same_binding(&access.current,¤t)?;
- if let Some(operation)=absent_operation {let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND grant_id=? AND operation_id=?").bind(current.actor().participant().as_bytes().as_slice()).bind(current.input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;if count!=0 {return Err(OperationError::RecoveryRequired);}}
+ if let Some(operation)=absent_operation {let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND operation_id=?").bind(current.actor().participant().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;if count!=0 {return Err(OperationError::RecoveryRequired);}}
if let Some(id)=absent_pool {let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_pools WHERE pool_id=?").bind(id.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;if count!=0 {return Err(OperationError::RecoveryRequired);}}
if let Some(retained)=operation {
- let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND grant_id=? AND operation_id=? AND protected=?").bind(current.actor().participant().as_bytes().as_slice()).bind(current.input().grant_id().as_bytes().as_slice()).bind(retained.receipt.attempt().operation_id().as_bytes().as_slice()).bind(&retained.protected).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
+ let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND operation_id=? AND protected=?").bind(current.actor().participant().as_bytes().as_slice()).bind(retained.receipt.attempt().operation_id().as_bytes().as_slice()).bind(&retained.protected).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
if count!=1 {return Err(OperationError::RecoveryRequired);}
- let movement_count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_movements WHERE actor=? AND grant_id=? AND operation_id=?").bind(current.actor().participant().as_bytes().as_slice()).bind(current.input().grant_id().as_bytes().as_slice()).bind(retained.receipt.attempt().operation_id().as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
+ let movement_count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?").bind(current.actor().participant().as_bytes().as_slice()).bind(retained.receipt.attempt().operation_id().as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
if movement_count!=i64::from(retained.movement.is_some()) {return Err(OperationError::RecoveryRequired);}
if let (Some(id),Some(protected))=(retained.movement,retained.movement_protected.as_ref()) {
let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_movements WHERE movement_id=? AND protected=?").bind(id.as_slice()).bind(protected).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;
@@ -408,6 +468,14 @@ impl Turn<'_> {
operation,
)
.await?;
+ if !access.record.allows_action(StockAction::ReadOperations) {
+ return Err(OperationError::Unauthorized);
+ }
+ if let Some(retained) = &result {
+ access
+ .record
+ .require(StockAction::ReadOperations, retained.receipt.pool().id())?;
+ }
if let Some(retained) = &result
&& digest.is_some_and(|d| d != retained.digest)
{
@@ -432,6 +500,7 @@ impl Turn<'_> {
proof: AttachmentProof,
) -> Result<Option<radroots_domain::stock::PoolView>, OperationError> {
let access = self.access(&binding, minimum, &proof).await?;
+ access.record.require(StockAction::ReadPools, id)?;
let result = read_pool(self.connection, self.selected, self.crypto, id).await?;
self.confirm(
&access,
@@ -502,6 +571,7 @@ async fn read_pool(
}))
}
struct Retained {
+ original_grant: GrantId,
previous_head: Option<CheckpointDigest>,
movement: Option<[u8; 32]>,
movement_protected: Option<Vec<u8>>,
@@ -516,8 +586,8 @@ async fn read_operation(
binding: &WorkspaceBinding,
operation: OperationId,
) -> Result<Option<Retained>, OperationError> {
- let row=sqlx::query("SELECT CASE WHEN length(command_digest)=32 THEN command_digest END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,CASE WHEN length(pool_id)=32 THEN pool_id END,revision,CASE WHEN length(chain_head)=32 THEN chain_head END,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_operations WHERE actor=? AND grant_id=? AND operation_id=?")
- .bind(binding.actor().participant().as_bytes().as_slice()).bind(binding.input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?;
+ let row=sqlx::query("SELECT CASE WHEN length(command_digest)=32 THEN command_digest END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,CASE WHEN length(pool_id)=32 THEN pool_id END,revision,CASE WHEN length(chain_head)=32 THEN chain_head END,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END,grant_id FROM stock_operations WHERE actor=? AND operation_id=?")
+ .bind(binding.actor().participant().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?;
let Some(row) = row else { return Ok(None) };
let protected: Vec<u8> = row
.try_get::<Option<Vec<u8>>, _>(5)
@@ -538,8 +608,19 @@ async fn read_operation(
.await?;
let (request, decoded) =
clear.expose_secret(|bytes| decode_operation(bytes, catalog, binding))?;
- same_binding(request.binding(), binding)?;
+ if !SellerAuthoritySelection::from_attachment(request.binding().input())
+ .matches_attachment(binding.input())
+ || request.binding().actor().participant() != binding.actor().participant()
+ {
+ return Err(OperationError::RecoveryRequired);
+ }
let digest = request.command().digest();
+ let original_grant: Vec<u8> = row
+ .try_get(6)
+ .map_err(|_| OperationError::RecoveryRequired)?;
+ if original_grant != request.binding().input().grant_id().as_bytes() {
+ return Err(OperationError::RecoveryRequired);
+ }
let (planned, quantity, movement_kind) = plan_effect(request.command(), decoded.before)
.map_err(|_| OperationError::RecoveryRequired)?;
if decoded.version != record_version(catalog)?
@@ -581,20 +662,18 @@ async fn read_operation(
if revision <= 0 || revision as u64 != decoded.revision.get() || head != decoded.head {
return Err(OperationError::RecoveryRequired);
}
- let count: i64 = sqlx::query_scalar(
- "SELECT count(*) FROM stock_movements WHERE actor=? AND grant_id=? AND operation_id=?",
- )
- .bind(binding.actor().participant().as_bytes().as_slice())
- .bind(binding.input().grant_id().as_bytes().as_slice())
- .bind(operation.as_bytes().as_slice())
- .fetch_one(&mut *connection)
- .await
- .map_err(|_| OperationError::RecoveryRequired)?;
+ let count: i64 =
+ sqlx::query_scalar("SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?")
+ .bind(binding.actor().participant().as_bytes().as_slice())
+ .bind(operation.as_bytes().as_slice())
+ .fetch_one(&mut *connection)
+ .await
+ .map_err(|_| OperationError::RecoveryRequired)?;
if count != i64::from(decoded.movement.is_some()) {
return Err(OperationError::RecoveryRequired);
}
let movement_protected = if let Some(id) = decoded.movement {
- let protected:Vec<u8>=sqlx::query_scalar("SELECT protected FROM stock_movements WHERE movement_id=? AND actor=? AND grant_id=? AND operation_id=? AND pool_id=? AND length(protected) BETWEEN 1 AND 262144").bind(id.as_slice()).bind(binding.actor().participant().as_bytes().as_slice()).bind(binding.input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(decoded.pool.id().as_bytes().as_slice()).fetch_optional(connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?;
+ let protected:Vec<u8>=sqlx::query_scalar("SELECT protected FROM stock_movements WHERE movement_id=? AND actor=? AND grant_id=? AND operation_id=? AND pool_id=? AND length(protected) BETWEEN 1 AND 262144").bind(id.as_slice()).bind(binding.actor().participant().as_bytes().as_slice()).bind(request.binding().input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(decoded.pool.id().as_bytes().as_slice()).fetch_optional(connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?;
let clear = crypto
.open_stock_record_for_catalog(input, "movement", &id, catalog, &protected)
.await?;
@@ -631,9 +710,11 @@ async fn read_operation(
request.command().context().authority(),
decoded.revision,
Some(decoded.head),
- )?,
+ )?
+ .with_optional_authorization(decoded.authorization),
)?;
Ok(Some(Retained {
+ original_grant: request.binding().input().grant_id(),
previous_head: decoded.previous_head,
movement: decoded.movement,
movement_protected,
diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs b/crates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs
@@ -3,13 +3,13 @@ use super::*;
/// Constant-memory witness of the exact protected ancestry checked before IO
/// enters the write transaction. The transaction rereads every bound SQL row;
/// no key-provider callback or decryption runs while it owns the SQL lock.
-pub(super) struct MinimumProof {
+pub(in crate::workspace::stock) struct MinimumProof {
lower: u64,
upper: u64,
digest: [u8; 32],
}
impl MinimumProof {
- pub(super) async fn confirm(
+ pub(in crate::workspace::stock) async fn confirm(
&self,
connection: &mut SqliteConnection,
) -> Result<(), OperationError> {
@@ -85,7 +85,7 @@ pub(super) async fn authenticate_minimum(
}
hash.update(revision.to_be_bytes());
hash.update(binding.actor().participant().as_bytes());
- hash.update(binding.input().grant_id().as_bytes());
+ hash.update(retained.original_grant.as_bytes());
hash.update(operation.as_bytes());
hash.update(retained.digest.as_bytes());
hash.update(
diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs
@@ -88,7 +88,35 @@ pub(super) struct OperationDecodeV2<'a> {
#[serde(deserialize_with = "super::required_nullable")]
pub(super) movement: Option<[u8; 32]>,
}
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct OperationV3<'a> {
+ version: u8,
+ authorization: StockAuthorizationRef,
+ #[serde(borrow)]
+ operation: &'a RawValue,
+}
+pub(super) fn encode_operation(
+ value: &OperationWire<'_>,
+ catalog: i64,
+ authorization: Option<StockAuthorizationRef>,
+) -> Result<zeroize::Zeroizing<Vec<u8>>, OperationError> {
+ let clear = super::encode(value)?;
+ if catalog != 4 {
+ return Ok(clear);
+ }
+ let raw = RawValue::from_string(
+ String::from_utf8(clear.to_vec()).map_err(|_| OperationError::StorageFailure)?,
+ )
+ .map_err(|_| OperationError::StorageFailure)?;
+ super::encode(&OperationV3 {
+ version: 3,
+ authorization: authorization.ok_or(OperationError::RecoveryRequired)?,
+ operation: &raw,
+ })
+}
pub(super) struct OperationData {
+ pub(super) authorization: Option<StockAuthorizationRef>,
pub(super) version: u8,
pub(super) before: Option<PoolSnapshot>,
pub(super) transaction: TransactionId,
@@ -102,8 +130,19 @@ pub(super) struct OperationData {
pub(super) fn decode_operation(
bytes: &[u8],
catalog: i64,
- binding: &WorkspaceBinding,
+ _binding: &WorkspaceBinding,
) -> Result<(InventoryRequest, OperationData), OperationError> {
+ if catalog == 4 {
+ let decoded: OperationV3<'_> =
+ super::closed_record(bytes).map_err(|_| OperationError::RecoveryRequired)?;
+ if decoded.version != 3 {
+ return Err(OperationError::RecoveryRequired);
+ }
+ let (request, mut data) =
+ decode_operation(decoded.operation.get().as_bytes(), 3, _binding)?;
+ data.authorization = Some(decoded.authorization);
+ return Ok((request, data));
+ }
macro_rules! captured {
($decoded:expr,$prior:expr) => {{
let decoded = $decoded;
@@ -111,7 +150,12 @@ pub(super) fn decode_operation(
let captured = WorkspaceBinding::from_authenticated_host(
decoded.selection,
decoded.scope,
- binding.actor(),
+ radroots_storage::inventory::CapturedInventoryCommand::parse(
+ decoded.command.get().as_bytes(),
+ )
+ .map_err(|_| OperationError::RecoveryRequired)?
+ .context()
+ .actor(),
decoded.principal,
decoded.grant_revision,
decoded.grant_expires_at,
@@ -130,6 +174,7 @@ pub(super) fn decode_operation(
Ok((
request,
OperationData {
+ authorization: None,
version: decoded.version,
before: prior,
transaction: decoded.transaction,
diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs b/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs
@@ -3,7 +3,7 @@ use super::*;
pub(super) fn record_version(catalog: i64) -> Result<u8, OperationError> {
match catalog {
2 => Ok(1),
- 3 => Ok(2),
+ 3 | 4 => Ok(2),
_ => Err(OperationError::RecoveryRequired),
}
}
diff --git a/crates/storage_sqlite/src/workspace/stock/schema.rs b/crates/storage_sqlite/src/workspace/stock/schema.rs
@@ -1,7 +1,7 @@
//! Exact stock catalogs. Enrollment-only version1 is retained without upgrade.
use super::WorkspaceError;
use sqlx::SqliteConnection;
-pub(super) const CURRENT: i64 = 3;
+pub(super) const CURRENT: i64 = 4;
const AUTHORITY: &str = "CREATE TABLE stock_authority (singleton INTEGER PRIMARY KEY CHECK(singleton=1), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT";
const GRANTS: &str = "CREATE TABLE stock_grants (grant_id BLOB PRIMARY KEY CHECK(length(grant_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID";
const POOLS: &str = "CREATE TABLE stock_pools (pool_id BLOB PRIMARY KEY CHECK(length(pool_id)=32), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID";
@@ -22,7 +22,7 @@ pub(super) fn objects(
];
match version {
1 => {}
- 2 | 3 => objects.extend([
+ 2..=4 => objects.extend([
("table", "stock_pools", "stock_pools", POOLS),
("table", "stock_operations", "stock_operations", OPERATIONS),
(
@@ -47,6 +47,16 @@ pub(super) fn objects(
]),
_ => return Err(WorkspaceError::RecoveryRequired),
}
+ if version == 4 {
+ objects.push(("table", "stock_grant_changes", "stock_grant_changes", "CREATE TABLE stock_grant_changes (transaction_id BLOB PRIMARY KEY CHECK(length(transaction_id)=32), revision INTEGER NOT NULL CHECK(revision>1), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"));
+ objects.push((
+ "index",
+ "stock_grant_change_revision",
+ "stock_grant_changes",
+ "CREATE UNIQUE INDEX stock_grant_change_revision ON stock_grant_changes(revision)",
+ ));
+ objects.push(("index", "stock_actor_operation_identity", "stock_operations", "CREATE UNIQUE INDEX stock_actor_operation_identity ON stock_operations(actor,operation_id)"));
+ }
Ok(objects)
}
pub(super) async fn admit(connection: &mut SqliteConnection) -> Result<i64, WorkspaceError> {
diff --git a/crates/storage_sqlite/src/workspace/stock/tests.rs b/crates/storage_sqlite/src/workspace/stock/tests.rs
@@ -16,7 +16,207 @@ impl WorkspaceClock for Clock {
}
#[tokio::test]
+async fn catalog4_grant_set_reopens_with_original_namespace_after_one_grant_change() {
+ let fixture = CryptoFixture::new();
+ let path = fixture.root().join("grant-reopen");
+ let enrollment = StockEnrollment::prepare(
+ SellerStockConfig::new(
+ participant(),
+ participant(),
+ "owner",
+ UnixSeconds::new(200).unwrap(),
+ )
+ .unwrap(),
+ &Clock,
+ )
+ .unwrap();
+ let store = NativeWorkspace::initialize_seller_stock(
+ &path,
+ &enrollment,
+ fixture.crypto(),
+ Arc::new(Clock),
+ )
+ .await
+ .unwrap();
+ let binding = store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ let minimum = store
+ .stock_authority(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap()
+ .inventory_checkpoint()
+ .unwrap();
+ let context = CommandContextData::new(
+ OperationId::from_bytes([7; 32]),
+ binding.actor(),
+ enrollment.input().workspace_id(),
+ enrollment.input().authority(),
+ enrollment.input().route_digest(),
+ None,
+ None,
+ UnixSeconds::new(150).unwrap(),
+ None,
+ )
+ .unwrap();
+ let wire = serde_json::json!({"type":"stock.create_pool","context":context,"input":{"id":PoolId::from_bytes([8;32]),"label":"reopen","unit":"each","tick_scale":"0","initial_quantity":"1"}});
+ let copy = enrollment
+ .proof()
+ .with_secret(|bytes| AttachmentProof::from_protected_input(bytes))
+ .unwrap();
+ let result = store
+ .execute_inventory(
+ InventoryRequest::from_protected_wire(
+ binding.clone(),
+ minimum,
+ &serde_json::to_vec(&wire).unwrap(),
+ )
+ .unwrap(),
+ copy,
+ )
+ .await
+ .unwrap();
+ let minimum = match result {
+ radroots_storage::inventory::InventoryOutcome::Committed(v) => v.checkpoint(),
+ _ => panic!("creation must confirm"),
+ };
+ let grant = StockGrantEnrollment::prepare(
+ &SellerAuthoritySelection::from_attachment(enrollment.input()),
+ "device".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ assert!(matches!(
+ store
+ .enroll_stock_grant(binding, minimum, enrollment.proof(), &grant)
+ .await
+ .unwrap(),
+ StockGrantOutcome::Committed(_)
+ ));
+ store.close().await.unwrap();
+ std::fs::copy(
+ path.join("stock_execution_v1.sqlite"),
+ fixture.root().join("synthetic-before-revocation.sqlite"),
+ )
+ .unwrap();
+ let namespace = Namespace::acquire_kind(&path, false, Kind::SellerStock).unwrap();
+ let mut connection = SqliteConnection::connect_with(
+ &sqlx::sqlite::SqliteConnectOptions::new()
+ .filename(namespace.database_path())
+ .read_only(true),
+ )
+ .await
+ .unwrap();
+ assert_eq!(schema::admit(&mut connection).await, Ok(4));
+ assert_eq!(schema::integrity(&mut connection).await, Ok(()));
+ let root: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_authority")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ let clear = fixture
+ .crypto()
+ .open_stock_root(enrollment.input(), 4, &root)
+ .await
+ .unwrap();
+ let authority = clear
+ .expose_secret(|bytes| Authority::decode(bytes, 4))
+ .unwrap();
+ assert_eq!(authority.input, *enrollment.input());
+ assert_eq!(
+ grants::check_state(&mut connection, authority.authorization.unwrap()).await,
+ Ok(())
+ );
+ assert!(
+ read(&mut connection, enrollment.input(), &fixture.crypto())
+ .await
+ .is_ok()
+ );
+ connection.close().await.unwrap();
+ drop(namespace);
+ let reopened = NativeWorkspace::open_seller_stock(
+ &path,
+ enrollment.input().clone(),
+ fixture.crypto(),
+ Arc::new(Clock),
+ )
+ .await
+ .unwrap();
+ reopened.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn root4_context_binds_the_complete_namespace_independently_of_caller_grants() {
+ use radroots_storage::workspace::seller_stock::SellerAuthoritySelection;
+ use serde_json::json;
+ let fixture = CryptoFixture::new();
+ let (owner, _, _) = SellerStockConfig::new(
+ participant(),
+ participant(),
+ "root-context",
+ UnixSeconds::new(200).unwrap(),
+ )
+ .unwrap()
+ .enroll(
+ UnixSeconds::new(100).unwrap(),
+ WorkspaceId::from_bytes([1; 32]),
+ ExecutorId::from_bytes([2; 32]),
+ GrantId::from_bytes([3; 32]),
+ AttachmentProof::from_protected_input(&[7; 32]).unwrap(),
+ )
+ .unwrap();
+ let namespace = SellerAuthoritySelection::from_attachment(&owner);
+ let caller = namespace.attachment(GrantId::from_bytes([9; 32])).unwrap();
+ let crypto = fixture.crypto();
+ let clear = b"synthetic context payload";
+ let current = crypto.seal_stock_root(&owner, 4, clear).await.unwrap();
+ crypto
+ .open_stock_root(&caller, 4, ¤t)
+ .await
+ .unwrap()
+ .expose_secret(|bytes| assert_eq!(bytes, clear));
+ let retained = crypto.seal_stock_root(&owner, 3, clear).await.unwrap();
+ assert!(crypto.open_stock_root(&caller, 3, &retained).await.is_err());
+ assert!(crypto.open_stock_root(&owner, 3, ¤t).await.is_err());
+ let value = serde_json::to_value(namespace).unwrap();
+ let other_key = "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5";
+ for (path, bad) in [
+ ("/workspace_id", json!("0b".repeat(32))),
+ ("/authority/executor_id", json!("0b".repeat(32))),
+ ("/authority/generation", json!("2")),
+ ("/participant", json!(other_key)),
+ ("/endpoint", json!("local://another-namespace")),
+ ("/endpoint_identity", json!(other_key)),
+ ("/checkpoint/digest", json!("0b".repeat(32))),
+ ("/route_digest", json!("0b".repeat(32))),
+ ] {
+ let mut changed = value.clone();
+ *changed.pointer_mut(path).unwrap() = bad;
+ let selected: SellerAuthoritySelection = serde_json::from_value(changed).unwrap();
+ assert!(
+ crypto
+ .open_stock_root(
+ &selected.attachment(GrantId::from_bytes([9; 32])).unwrap(),
+ 4,
+ ¤t
+ )
+ .await
+ .is_err(),
+ "{path}"
+ );
+ }
+}
+
+#[tokio::test]
async fn retained_inventory_v2_keeps_original_records_and_refuses_new_correction_without_upgrade() {
+ retained_inventory_catalog(2).await;
+}
+#[tokio::test]
+async fn retained_inventory_v3_preserves_correction_and_original_records_without_upgrade() {
+ retained_inventory_catalog(3).await;
+}
+async fn retained_inventory_catalog(catalog: i64) {
use radroots_storage::inventory::{InventoryCommandKind, InventoryOutcome};
let fixture = CryptoFixture::new();
let path = fixture.root().join("retained-v2");
@@ -35,10 +235,13 @@ async fn retained_inventory_v2_keeps_original_records_and_refuses_new_correction
AttachmentProof::from_protected_input(&[0xA3; 32]).unwrap(),
)
.unwrap();
- // Literal catalog2/root2 shape from cc96f676, not predecessor-binary evidence.
- let clear=zeroize::Zeroizing::new(serde_json::to_vec(&serde_json::json!({"version":2,"input":input,"transaction":TransactionId::from_bytes([9;32]),"revocation":"1","inventory":{"revision":"0","pools":"0","movements":"0","head":null}})).unwrap());
+ // Literal retained catalog/root shapes from published creation/correction source; not predecessor-binary evidence.
+ let clear=zeroize::Zeroizing::new(serde_json::to_vec(&serde_json::json!({"version":catalog,"input":input,"transaction":TransactionId::from_bytes([9;32]),"revocation":"1","inventory":{"revision":"0","pools":"0","movements":"0","head":null}})).unwrap());
let crypto = fixture.crypto();
- let root = crypto.seal_stock_root(&input, 2, &clear).await.unwrap();
+ let root = crypto
+ .seal_stock_root(&input, catalog, &clear)
+ .await
+ .unwrap();
let grant = crypto
.seal_stock(&input, false, &record.encode().unwrap())
.await
@@ -53,7 +256,7 @@ async fn retained_inventory_v2_keeps_original_records_and_refuses_new_correction
.await
.unwrap();
let mut tx = connection.begin_with("BEGIN IMMEDIATE").await.unwrap();
- for (_, _, _, sql) in schema::objects(2).unwrap() {
+ for (_, _, _, sql) in schema::objects(catalog).unwrap() {
sqlx::raw_sql(sql).execute(&mut *tx).await.unwrap();
}
sqlx::query("INSERT INTO stock_authority(singleton,protected) VALUES(1,?)")
@@ -67,10 +270,14 @@ async fn retained_inventory_v2_keeps_original_records_and_refuses_new_correction
.execute(&mut *tx)
.await
.unwrap();
- sqlx::query("PRAGMA user_version=2")
- .execute(&mut *tx)
- .await
- .unwrap();
+ sqlx::query(if catalog == 2 {
+ "PRAGMA user_version=2"
+ } else {
+ "PRAGMA user_version=3"
+ })
+ .execute(&mut *tx)
+ .await
+ .unwrap();
tx.commit().await.unwrap();
connection.close().await.unwrap();
drop(namespace);
@@ -141,50 +348,72 @@ async fn retained_inventory_v2_keeps_original_records_and_refuses_new_correction
);
let mut corrected = serde_json::json!({"type":"stock.adjust","context":context,"input":{"pool_id":PoolId::from_bytes([8;32]),"expected_version":"1","direction":"add","amount":"1","reason":"new correction profile"}});
corrected["context"]["operation_id"] = serde_json::json!(OperationId::from_bytes([10; 32]));
- assert!(matches!(
- store
- .execute_inventory(
- InventoryRequest::from_protected_wire(
- binding,
- created.checkpoint(),
- &serde_json::to_vec(&corrected).unwrap()
- )
- .unwrap(),
- copy()
+ let correction = store
+ .execute_inventory(
+ InventoryRequest::from_protected_wire(
+ binding,
+ created.checkpoint(),
+ &serde_json::to_vec(&corrected).unwrap(),
)
- .await,
- Err(OperationError::UnsupportedOperation)
- ));
+ .unwrap(),
+ copy(),
+ )
+ .await;
+ if catalog == 2 {
+ assert!(matches!(
+ correction,
+ Err(OperationError::UnsupportedOperation)
+ ));
+ } else {
+ match correction.unwrap() {
+ InventoryOutcome::Committed(value) => {
+ assert_eq!(value.pool().version().get(), 2);
+ assert_eq!(value.pool().balances().physical().available.get(), 2);
+ }
+ InventoryOutcome::Unknown(_) => panic!("retained correction must confirm"),
+ }
+ }
store.close().await.unwrap();
let mut connection = SqliteConnection::connect_with(
&sqlx::sqlite::SqliteConnectOptions::new().filename(path.join("stock_execution_v1.sqlite")),
)
.await
.unwrap();
- assert_eq!(schema::admit(&mut connection).await.unwrap(), 2);
- let protected: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_operations")
- .fetch_one(&mut connection)
- .await
- .unwrap();
+ assert_eq!(schema::admit(&mut connection).await.unwrap(), catalog);
+ let protected: Vec<u8> =
+ sqlx::query_scalar("SELECT protected FROM stock_operations WHERE operation_id=?")
+ .bind(OperationId::from_bytes([7; 32]).as_bytes().as_slice())
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
let old = fixture
.crypto()
- .open_stock_record(
+ .open_stock_record_for_catalog(
&input,
"operation",
OperationId::from_bytes([7; 32]).as_bytes(),
+ catalog,
&protected,
)
.await
.unwrap();
old.expose_secret(|bytes| {
let value: serde_json::Value = serde_json::from_slice(bytes).unwrap();
- assert_eq!(value["version"], 1);
- assert!(value.get("before").is_none());
+ assert_eq!(value["version"], if catalog == 2 { 1 } else { 2 });
+ if catalog == 2 {
+ assert!(value.get("before").is_none());
+ } else {
+ assert_eq!(value["before"], serde_json::Value::Null);
+ }
});
- sqlx::query("PRAGMA user_version=3")
- .execute(&mut connection)
- .await
- .unwrap();
+ sqlx::query(if catalog == 2 {
+ "PRAGMA user_version=3"
+ } else {
+ "PRAGMA user_version=4"
+ })
+ .execute(&mut connection)
+ .await
+ .unwrap();
connection.close().await.unwrap();
assert!(
NativeWorkspace::open_seller_stock(&path, input, fixture.crypto(), Arc::new(Clock))
diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs
@@ -38,6 +38,11 @@ const QUEUE_MAX_BYTES: usize = 4 * 1024 * 1024;
const QUEUE_CAPACITY: usize = 32;
type Reply<T, E = WorkspaceError> = oneshot::Sender<Result<T, E>>;
enum Job {
+ ChangeStockGrant(
+ Box<stock::grants::Change>,
+ AttachmentProof,
+ Reply<stock::StockGrantOutcome>,
+ ),
ExecuteInventory(
Box<radroots_storage::inventory::InventoryRequest>,
AttachmentProof,
@@ -163,6 +168,9 @@ enum Job {
impl Job {
fn reject_recovery(self) {
match self {
+ Self::ChangeStockGrant(_, _, reply) => {
+ let _ = reply.send(Err(WorkspaceError::RecoveryRequired));
+ }
Self::ExecuteInventory(_, _, reply) => {
let _ = reply.send(Err(OperationError::RecoveryRequired));
}
@@ -365,6 +373,7 @@ impl Handle {
&& !matches!(
&job,
Job::Authenticate(..)
+ | Job::ChangeStockGrant(..)
| Job::ExecuteInventory(..)
| Job::InventoryOperation(..)
| Job::Pool(..)
@@ -399,6 +408,26 @@ impl Handle {
continue;
};
match job {
+ Job::ChangeStockGrant(change, proof, reply) => {
+ let result = if kind == Kind::SellerStock && !uncertain {
+ stock::grants::change(
+ &mut stock::inventory::Turn {
+ connection,
+ namespace: &namespace,
+ selected: &input,
+ crypto: &crypto,
+ clock: clock.as_ref(),
+ uncertain: &mut uncertain,
+ },
+ *change,
+ proof,
+ )
+ .await
+ } else {
+ Err(WorkspaceError::RecoveryRequired)
+ };
+ let _ = reply.send(result);
+ }
Job::ExecuteInventory(request, proof, reply) => {
let result = if kind == Kind::SellerStock {
stock::inventory::Turn {
@@ -796,6 +825,18 @@ impl Handle {
}
}
}
+ pub(super) async fn change_stock_grant(
+ &self,
+ change: stock::grants::Change,
+ proof: AttachmentProof,
+ ) -> Result<stock::StockGrantOutcome, WorkspaceError> {
+ let transaction = change.transaction;
+ let (reply, receive) = oneshot::channel();
+ self.send(Job::ChangeStockGrant(Box::new(change), proof, reply))?;
+ receive
+ .await
+ .unwrap_or(Ok(stock::StockGrantOutcome::Unknown(transaction)))
+ }
pub(super) async fn stock_authority(
&self,
input: AttachmentInput,
@@ -857,7 +898,7 @@ impl Handle {
}
fn send(&self, job: Job) -> Result<(), WorkspaceError> {
let bytes = match &job {
- Job::ExecuteInventory(..) => 64 * 1024,
+ Job::ChangeStockGrant(..) | Job::ExecuteInventory(..) => 64 * 1024,
Job::CaptureDeliveryObservation(..) => 96 * 1024,
Job::PrepareDelivery(..) => 1024 * 1024,
Job::BindPlan(..) => 1024 * 1024,
diff --git a/crates/storage_sqlite/tests/support/pool_creation.rs b/crates/storage_sqlite/tests/support/pool_creation.rs
@@ -25,6 +25,7 @@ fn minimum(binding: &radroots_storage::workspace::WorkspaceBinding) -> Inventory
None,
)
.unwrap()
+ .with_optional_authorization(binding.stock_authorization())
}
fn request(
binding: &radroots_storage::workspace::WorkspaceBinding,
@@ -741,7 +742,20 @@ async fn current_credentials_guard_pool_reads_replay_and_new_effects_after_revoc
.await,
Err(OperationError::Workspace(WorkspaceError::Unauthorized))
));
- store.revoke(e.input().clone(), e.proof()).await.unwrap();
+ let revoked = store
+ .revoke_stock_grant(
+ binding.clone(),
+ receipt.checkpoint(),
+ e.proof(),
+ radroots_domain::TransactionId::from_bytes([0xAE; 32]),
+ e.input().grant_id(),
+ )
+ .await
+ .unwrap();
+ assert!(matches!(
+ revoked,
+ radroots_storage_sqlite::workspace::StockGrantOutcome::Committed(_)
+ ));
assert!(matches!(
store
.execute_inventory(request(&binding, 1, 2, "Carrots"), proof(e.proof()))
@@ -957,3 +971,6 @@ async fn acknowledged_branch_cannot_be_satisfied_by_unprotected_history_index_fi
#[path = "pool_correction.rs"]
mod correction;
+
+#[path = "stock_grants.rs"]
+mod grants;
diff --git a/crates/storage_sqlite/tests/support/stock_authority.rs b/crates/storage_sqlite/tests/support/stock_authority.rs
@@ -25,6 +25,51 @@ async fn reopen(f: &Fixture, e: &StockEnrollment) -> NativeWorkspace {
.await
.unwrap()
}
+// Prepared outside the future under test so observer loss cannot discard a
+// not-yet-submitted revocation. Production callers retain its actual receipt.
+struct PreparedRevocation {
+ binding: radroots_storage::workspace::WorkspaceBinding,
+ minimum: radroots_storage::inventory::InventoryCheckpointRef,
+ transaction: radroots_domain::TransactionId,
+}
+impl PreparedRevocation {
+ async fn new(store: &NativeWorkspace, e: &StockEnrollment) -> Self {
+ Self {
+ binding: store
+ .authenticate(e.input().clone(), e.proof())
+ .await
+ .unwrap(),
+ minimum: store
+ .stock_authority(e.input().clone(), e.proof())
+ .await
+ .unwrap()
+ .inventory_checkpoint()
+ .unwrap(),
+ transaction: radroots_domain::TransactionId::from_bytes([0xAD; 32]),
+ }
+ }
+ async fn run(
+ &self,
+ store: &NativeWorkspace,
+ e: &StockEnrollment,
+ ) -> Result<(), WorkspaceError> {
+ match store
+ .revoke_stock_grant(
+ self.binding.clone(),
+ self.minimum,
+ e.proof(),
+ self.transaction,
+ e.input().grant_id(),
+ )
+ .await?
+ {
+ radroots_storage_sqlite::workspace::StockGrantOutcome::Committed(_) => Ok(()),
+ radroots_storage_sqlite::workspace::StockGrantOutcome::Unknown(_) => {
+ Err(WorkspaceError::CommitUnknown)
+ }
+ }
+ }
+}
#[tokio::test]
async fn explicit_stock_creation_has_retained_receipt_and_reopens() {
let f = Fixture::new();
@@ -62,6 +107,7 @@ async fn proof_expiry_revocation_and_wrong_selection_are_current() {
let f = Fixture::new();
let e = enrollment(&f);
let store = create(&f, &e).await;
+ let prepared_revocation = PreparedRevocation::new(&store, &e).await;
let wrong = AttachmentProof::from_protected_input(&[0xAB; 32]).unwrap();
assert_eq!(
store.authenticate(e.input().clone(), &wrong).await,
@@ -81,7 +127,7 @@ async fn proof_expiry_revocation_and_wrong_selection_are_current() {
Err(WorkspaceError::GrantExpired)
);
f.clock.0.store(100, Ordering::SeqCst);
- store.revoke(e.input().clone(), e.proof()).await.unwrap();
+ prepared_revocation.run(&store, &e).await.unwrap();
assert_eq!(
store.authenticate(e.input().clone(), e.proof()).await,
Err(WorkspaceError::GrantRevoked)
@@ -215,8 +261,9 @@ async fn cancelled_stock_revocation_drains_then_remains_revoked() {
let store = NativeWorkspace::initialize_seller_stock(&f.path, &e, f.crypto(), clock.clone())
.await
.unwrap();
+ let prepared_revocation = PreparedRevocation::new(&store, &e).await;
clock.arm();
- let mut revoked = Box::pin(store.revoke(e.input().clone(), e.proof()));
+ let mut revoked = Box::pin(prepared_revocation.run(&store, &e));
assert!(futures::poll!(revoked.as_mut()).is_pending());
clock.entered();
drop(revoked);
@@ -243,6 +290,7 @@ async fn actual_commit_error_fences_the_owner_until_original_state_reopens() {
let f = Fixture::new();
let e = enrollment(&f);
let store = create(&f, &e).await;
+ let prepared_revocation = PreparedRevocation::new(&store, &e).await;
let database = f.path.join("stock_execution_v1.sqlite");
let mut connection = sqlx::SqliteConnection::connect_with(
&sqlx::sqlite::SqliteConnectOptions::new().filename(&database),
@@ -251,7 +299,7 @@ async fn actual_commit_error_fences_the_owner_until_original_state_reopens() {
.unwrap();
sqlx::raw_sql("CREATE TABLE deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER fail_commit AFTER UPDATE ON stock_grants BEGIN INSERT INTO deferred_fault VALUES(2); END").execute(&mut connection).await.unwrap();
assert_eq!(
- store.revoke(e.input().clone(), e.proof()).await,
+ prepared_revocation.run(&store, &e).await,
Err(WorkspaceError::CommitUnknown)
);
assert_eq!(
@@ -406,6 +454,7 @@ async fn statement_failure_rolls_back_both_revocation_records() {
let f = Fixture::new();
let e = enrollment(&f);
let store = create(&f, &e).await;
+ let prepared_revocation = PreparedRevocation::new(&store, &e).await;
let mut connection = sqlx::SqliteConnection::connect_with(
&sqlx::sqlite::SqliteConnectOptions::new()
.filename(f.path.join("stock_execution_v1.sqlite")),
@@ -414,7 +463,7 @@ async fn statement_failure_rolls_back_both_revocation_records() {
.unwrap();
sqlx::raw_sql("CREATE TRIGGER fail_revocation BEFORE UPDATE ON stock_grants BEGIN SELECT RAISE(ABORT,'fault'); END").execute(&mut connection).await.unwrap();
assert_eq!(
- store.revoke(e.input().clone(), e.proof()).await,
+ prepared_revocation.run(&store, &e).await,
Err(WorkspaceError::StorageFailure)
);
let receipt = store
@@ -524,11 +573,12 @@ async fn changed_catalog_after_protected_reads_is_refused_before_authenticated_c
NativeWorkspace::initialize_seller_stock(&f.path, &e, f.crypto(), clock.clone())
.await
.unwrap();
+ let prepared_revocation = PreparedRevocation::new(&store, &e).await;
clock.arm();
let mut operation: std::pin::Pin<
Box<dyn std::future::Future<Output = Result<(), WorkspaceError>> + '_>,
> = if revocation {
- Box::pin(store.revoke(e.input().clone(), e.proof()))
+ Box::pin(prepared_revocation.run(&store, &e))
} else {
Box::pin(async {
store
@@ -552,7 +602,7 @@ async fn changed_catalog_after_protected_reads_is_refused_before_authenticated_c
clock.release();
assert_eq!(operation.await, Err(WorkspaceError::RecoveryRequired));
store.close().await.unwrap();
- sqlx::query("PRAGMA user_version=3")
+ sqlx::query("PRAGMA user_version=4")
.execute(&mut connection)
.await
.unwrap();
diff --git a/crates/storage_sqlite/tests/support/stock_grants.rs b/crates/storage_sqlite/tests/support/stock_grants.rs
@@ -0,0 +1,802 @@
+use super::*;
+use radroots_domain::TransactionId;
+use radroots_storage::workspace::seller_stock::{
+ SellerAuthoritySelection, StockAction, StockGrantScope, StockResources,
+};
+use radroots_storage_sqlite::workspace::{StockGrantEnrollment, StockGrantOutcome};
+
+#[tokio::test]
+async fn cancelled_enrollment_drains_and_recovers_the_original_grant_transaction() {
+ let f = Fixture::new();
+ let enrollment = StockEnrollment::prepare(
+ SellerStockConfig::new(key(), key(), "owner", UnixSeconds::new(200).unwrap()).unwrap(),
+ f.clock.as_ref(),
+ )
+ .unwrap();
+ let clock = Arc::new(PausedClock {
+ state: std::sync::Mutex::new((false, false, false)),
+ changed: std::sync::Condvar::new(),
+ });
+ let store =
+ NativeWorkspace::initialize_seller_stock(&f.path, &enrollment, f.crypto(), clock.clone())
+ .await
+ .unwrap();
+ let owner = store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ let current = minimum(&owner);
+ let delegated = StockGrantEnrollment::prepare(
+ &SellerAuthoritySelection::from_attachment(owner.input()),
+ "cancelled-device".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ clock.arm();
+ let mut operation =
+ Box::pin(store.enroll_stock_grant(owner.clone(), current, enrollment.proof(), &delegated));
+ assert!(futures::poll!(operation.as_mut()).is_pending());
+ clock.entered();
+ drop(operation);
+ let mut closing = Box::pin(store.close());
+ assert!(futures::poll!(closing.as_mut()).is_pending());
+ drop(closing);
+ assert!(matches!(
+ NativeWorkspace::open_seller_stock(
+ &f.path,
+ enrollment.input().clone(),
+ f.crypto(),
+ f.clock.clone()
+ )
+ .await,
+ Err(WorkspaceError::WriterActive)
+ ));
+ clock.release();
+ store.close().await.unwrap();
+ let reopened = NativeWorkspace::open_seller_stock(
+ &f.path,
+ delegated.input().clone(),
+ f.crypto(),
+ f.clock.clone(),
+ )
+ .await
+ .unwrap();
+ assert!(
+ reopened
+ .authenticate(delegated.input().clone(), delegated.proof())
+ .await
+ .is_ok()
+ );
+ let original = grant_committed(
+ reopened
+ .enroll_stock_grant(owner, current, enrollment.proof(), &delegated)
+ .await
+ .unwrap(),
+ );
+ assert_eq!(original.transaction_id(), delegated.transaction_id());
+ reopened.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn grant_capacity_is_explicit_and_revoked_credentials_are_never_evicted_to_admit_new_grants()
+{
+ let f = Fixture::new();
+ let (store, enrollment, owner) = create(&f).await;
+ let namespace = SellerAuthoritySelection::from_attachment(owner.input());
+ let mut current = minimum(&owner);
+ let mut first = None;
+ for index in 0..63 {
+ let grant = StockGrantEnrollment::prepare(
+ &namespace,
+ format!("bounded-device-{index}"),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ let receipt = grant_committed(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &grant)
+ .await
+ .unwrap(),
+ );
+ current = current.with_authorization(receipt.authorization());
+ if index == 0 {
+ first = Some(grant);
+ }
+ }
+ let first = first.unwrap();
+ let receipt = grant_committed(
+ store
+ .revoke_stock_grant(
+ owner.clone(),
+ current,
+ enrollment.proof(),
+ TransactionId::from_bytes([111; 32]),
+ first.input().grant_id(),
+ )
+ .await
+ .unwrap(),
+ );
+ current = current.with_authorization(receipt.authorization());
+ let over = StockGrantEnrollment::prepare(
+ &namespace,
+ "over-capacity".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ assert_eq!(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &over)
+ .await,
+ Err(WorkspaceError::Capacity)
+ );
+ assert_eq!(
+ store
+ .authenticate(first.input().clone(), first.proof())
+ .await,
+ Err(WorkspaceError::GrantRevoked)
+ );
+ assert_eq!(
+ checkpoint(&store, owner.input(), enrollment.proof()).await,
+ current
+ );
+ store.close().await.unwrap();
+}
+
+struct RegressingClock {
+ calls: std::sync::atomic::AtomicUsize,
+ regress_at: std::sync::atomic::AtomicUsize,
+}
+impl RegressingClock {
+ fn new() -> Self {
+ Self {
+ calls: std::sync::atomic::AtomicUsize::new(0),
+ regress_at: std::sync::atomic::AtomicUsize::new(usize::MAX),
+ }
+ }
+ fn arm(&self, at: usize) {
+ self.calls.store(0, Ordering::SeqCst);
+ self.regress_at.store(at, Ordering::SeqCst);
+ }
+}
+impl WorkspaceClock for RegressingClock {
+ fn now(&self) -> Result<UnixSeconds, WorkspaceError> {
+ let count = self.calls.fetch_add(1, Ordering::SeqCst) + 1;
+ Ok(
+ UnixSeconds::new(if count >= self.regress_at.load(Ordering::SeqCst) {
+ 50
+ } else {
+ 100
+ })
+ .unwrap(),
+ )
+ }
+}
+#[tokio::test]
+async fn current_grant_clock_regression_refuses_fresh_and_retained_administrative_completion() {
+ for regress_at in [1, 3] {
+ let f = Fixture::new();
+ let clock = Arc::new(RegressingClock::new());
+ let enrollment = StockEnrollment::prepare(
+ SellerStockConfig::new(key(), key(), "owner", UnixSeconds::new(200).unwrap()).unwrap(),
+ clock.as_ref(),
+ )
+ .unwrap();
+ let store = NativeWorkspace::initialize_seller_stock(
+ &f.path,
+ &enrollment,
+ f.crypto(),
+ clock.clone(),
+ )
+ .await
+ .unwrap();
+ let owner = store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ let current = minimum(&owner);
+ let grant = StockGrantEnrollment::prepare(
+ &SellerAuthoritySelection::from_attachment(owner.input()),
+ "clock-device".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ clock.arm(regress_at);
+ assert_eq!(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &grant)
+ .await,
+ Err(WorkspaceError::Unavailable)
+ );
+ clock.arm(usize::MAX);
+ assert_eq!(
+ checkpoint(&store, owner.input(), enrollment.proof()).await,
+ current
+ );
+ let first = grant_committed(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &grant)
+ .await
+ .unwrap(),
+ );
+ clock.arm(2);
+ assert_eq!(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &grant)
+ .await,
+ Err(WorkspaceError::Unavailable)
+ );
+ clock.arm(usize::MAX);
+ assert_eq!(
+ grant_committed(
+ store
+ .enroll_stock_grant(owner, current, enrollment.proof(), &grant)
+ .await
+ .unwrap()
+ ),
+ first
+ );
+ store.close().await.unwrap();
+ }
+}
+
+fn grant_committed(
+ value: StockGrantOutcome,
+) -> radroots_storage_sqlite::workspace::StockGrantReceipt {
+ match value {
+ StockGrantOutcome::Committed(v) => v,
+ StockGrantOutcome::Unknown(_) => panic!("expected confirmed grant mutation"),
+ }
+}
+async fn checkpoint(
+ store: &NativeWorkspace,
+ input: &radroots_storage::workspace::AttachmentInput,
+ proof: &AttachmentProof,
+) -> InventoryCheckpointRef {
+ store
+ .stock_authority(input.clone(), proof)
+ .await
+ .unwrap()
+ .inventory_checkpoint()
+ .unwrap()
+}
+#[tokio::test]
+async fn scoped_grants_execute_and_replay_original_inventory_without_reallocation_and_revoke_current_access()
+ {
+ let f = Fixture::new();
+ let (store, enrollment, owner) = create(&f).await;
+ let initial = minimum(&owner);
+ let original = request(&owner, 91, 92, "scoped original");
+ let digest = original.command().digest();
+ let captured = original.command().protected_wire().to_vec();
+ let effect = committed(
+ store
+ .execute_inventory(original, proof(enrollment.proof()))
+ .await
+ .unwrap(),
+ );
+ let namespace = SellerAuthoritySelection::from_attachment(owner.input());
+ let delegated = StockGrantEnrollment::prepare(
+ &namespace,
+ "scoped-device".to_owned(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::new(
+ StockResources::pools(vec![PoolId::from_bytes([92; 32])]).unwrap(),
+ vec![
+ StockAction::ReadPools,
+ StockAction::ReadOperations,
+ StockAction::AddStock,
+ ],
+ )
+ .unwrap(),
+ )
+ .unwrap();
+ let added = grant_committed(
+ store
+ .enroll_stock_grant(
+ owner.clone(),
+ effect.checkpoint(),
+ enrollment.proof(),
+ &delegated,
+ )
+ .await
+ .unwrap(),
+ );
+ assert_eq!(added.transaction_id(), delegated.transaction_id());
+ assert_eq!(added.authorization().generation().get(), 2);
+ let current = checkpoint(&store, owner.input(), enrollment.proof()).await;
+ assert_eq!(current.authorization(), Some(added.authorization()));
+ let device = store
+ .authenticate(delegated.input().clone(), delegated.proof())
+ .await
+ .unwrap();
+ // Old acknowledged grant state cannot be reused after mutation.
+ assert_eq!(
+ store
+ .pool(
+ owner.clone(),
+ initial,
+ PoolId::from_bytes([92; 32]),
+ proof(enrollment.proof())
+ )
+ .await,
+ Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint))
+ );
+ assert!(
+ store
+ .pool(
+ device.clone(),
+ current,
+ PoolId::from_bytes([92; 32]),
+ proof(delegated.proof())
+ )
+ .await
+ .unwrap()
+ .is_some()
+ );
+ assert_eq!(
+ store
+ .pool(
+ device.clone(),
+ current,
+ PoolId::from_bytes([93; 32]),
+ proof(delegated.proof())
+ )
+ .await,
+ Err(OperationError::Unauthorized)
+ );
+ let retained = store
+ .inventory_operation(
+ device.clone(),
+ current,
+ OperationId::from_bytes([91; 32]),
+ Some(digest),
+ proof(delegated.proof()),
+ )
+ .await
+ .unwrap()
+ .unwrap();
+ assert_eq!(retained, effect);
+ let replay =
+ InventoryRequest::replay_from_protected_wire(device.clone(), current, &captured).unwrap();
+ assert!(InventoryRequest::from_protected_wire(device.clone(), current, &captured).is_err());
+ let unseen = request(&owner, 99, 92, "missing retained command");
+ let unseen = InventoryRequest::replay_from_protected_wire(
+ device.clone(),
+ current,
+ unseen.command().protected_wire(),
+ )
+ .unwrap();
+ assert_eq!(
+ store
+ .execute_inventory(unseen, proof(delegated.proof()))
+ .await,
+ Err(OperationError::RecoveryRequired)
+ );
+ assert_eq!(
+ committed(
+ store
+ .execute_inventory(replay, proof(delegated.proof()))
+ .await
+ .unwrap()
+ ),
+ effect
+ );
+ // Reusing the same operation with another grant creates a different exact
+ // command digest and cannot acquire a second stock effect.
+ let conflict = request(&device, 91, 92, "scoped original");
+ let conflict = InventoryRequest::from_protected_wire(
+ device.clone(),
+ current,
+ conflict.command().protected_wire(),
+ )
+ .unwrap();
+ assert_eq!(
+ store
+ .execute_inventory(conflict, proof(delegated.proof()))
+ .await,
+ Err(OperationError::IdempotencyConflict)
+ );
+ let forbidden = request(&device, 94, 92, "cannot create");
+ let forbidden = InventoryRequest::from_protected_wire(
+ device.clone(),
+ current,
+ forbidden.command().protected_wire(),
+ )
+ .unwrap();
+ assert_eq!(
+ store
+ .execute_inventory(forbidden, proof(delegated.proof()))
+ .await,
+ Err(OperationError::Unauthorized)
+ );
+ let another = StockGrantEnrollment::prepare(
+ &namespace,
+ "no-admin".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ assert_eq!(
+ store
+ .enroll_stock_grant(device.clone(), current, delegated.proof(), &another)
+ .await,
+ Err(WorkspaceError::Unauthorized)
+ );
+ let context = CommandContextData::new(
+ OperationId::from_bytes([96; 32]),
+ device.actor(),
+ device.input().workspace_id(),
+ device.input().authority(),
+ device.input().route_digest(),
+ None,
+ None,
+ UnixSeconds::new(150).unwrap(),
+ None,
+ )
+ .unwrap();
+ let mut wire = serde_json::json!({"type":"stock.adjust","context":context,"input":{"pool_id":PoolId::from_bytes([92;32]),"expected_version":"1","direction":"add","amount":"0.125","reason":"delegated harvest"}});
+ let add = InventoryRequest::from_protected_wire(
+ device.clone(),
+ current,
+ &serde_json::to_vec(&wire).unwrap(),
+ )
+ .unwrap();
+ let added_stock = committed(
+ store
+ .execute_inventory(add, proof(delegated.proof()))
+ .await
+ .unwrap(),
+ );
+ assert_eq!(
+ added_stock.pool().balances().physical().available.get(),
+ 375
+ );
+ wire["context"]["operation_id"] = serde_json::json!(OperationId::from_bytes([97; 32]));
+ wire["input"]["expected_version"] = serde_json::json!("2");
+ wire["input"]["direction"] = serde_json::json!("remove");
+ let remove = InventoryRequest::from_protected_wire(
+ device.clone(),
+ added_stock.checkpoint(),
+ &serde_json::to_vec(&wire).unwrap(),
+ )
+ .unwrap();
+ assert_eq!(
+ store
+ .execute_inventory(remove, proof(delegated.proof()))
+ .await,
+ Err(OperationError::Unauthorized)
+ );
+ let current = added_stock.checkpoint();
+ let revoked = grant_committed(
+ store
+ .revoke_stock_grant(
+ owner.clone(),
+ current,
+ enrollment.proof(),
+ TransactionId::from_bytes([95; 32]),
+ delegated.input().grant_id(),
+ )
+ .await
+ .unwrap(),
+ );
+ assert_eq!(revoked.authorization().generation().get(), 3);
+ assert_eq!(
+ store
+ .authenticate(delegated.input().clone(), delegated.proof())
+ .await,
+ Err(WorkspaceError::GrantRevoked)
+ );
+ let next = current.with_authorization(revoked.authorization());
+ assert_eq!(
+ store
+ .inventory_operation(
+ device,
+ next,
+ OperationId::from_bytes([91; 32]),
+ Some(digest),
+ proof(delegated.proof())
+ )
+ .await,
+ Err(OperationError::Workspace(WorkspaceError::GrantRevoked))
+ );
+ let mut connection = database(&f).await;
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_operations")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(count, 2);
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grant_changes")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(count, 2);
+ connection.close().await.unwrap();
+ store.close().await.unwrap();
+ let reopened = NativeWorkspace::open_seller_stock(
+ &f.path,
+ delegated.input().clone(),
+ f.crypto(),
+ f.clock.clone(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(
+ reopened
+ .authenticate(delegated.input().clone(), delegated.proof())
+ .await,
+ Err(WorkspaceError::GrantRevoked)
+ );
+ let owner = reopened
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ assert!(
+ reopened
+ .pool(
+ owner,
+ next,
+ PoolId::from_bytes([92; 32]),
+ proof(enrollment.proof())
+ )
+ .await
+ .unwrap()
+ .is_some()
+ );
+ reopened.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn acknowledged_revocation_refuses_a_complete_older_database_and_partial_grant_restore() {
+ let f = Fixture::new();
+ let (store, enrollment, owner) = create(&f).await;
+ let pool = committed(
+ store
+ .execute_inventory(
+ request(&owner, 101, 102, "restore stock"),
+ proof(enrollment.proof()),
+ )
+ .await
+ .unwrap(),
+ );
+ let delegated = StockGrantEnrollment::prepare(
+ &SellerAuthoritySelection::from_attachment(owner.input()),
+ "restore-device".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ grant_committed(
+ store
+ .enroll_stock_grant(
+ owner.clone(),
+ pool.checkpoint(),
+ enrollment.proof(),
+ &delegated,
+ )
+ .await
+ .unwrap(),
+ );
+ let before = checkpoint(&store, owner.input(), enrollment.proof()).await;
+ store.close().await.unwrap();
+ let original = f.path.join("stock_execution_v1.sqlite");
+ let backup = f
+ .path
+ .parent()
+ .unwrap()
+ .join("synthetic-before-revocation.sqlite");
+ std::fs::copy(&original, &backup).unwrap();
+ let store = NativeWorkspace::open_seller_stock(
+ &f.path,
+ enrollment.input().clone(),
+ f.crypto(),
+ f.clock.clone(),
+ )
+ .await
+ .unwrap();
+ let owner = store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ let mut connection = database(&f).await;
+ let old_grant: Vec<u8> =
+ sqlx::query_scalar("SELECT protected FROM stock_grants WHERE grant_id=?")
+ .bind(delegated.input().grant_id().as_bytes().as_slice())
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ let receipt = grant_committed(
+ store
+ .revoke_stock_grant(
+ owner.clone(),
+ before,
+ enrollment.proof(),
+ TransactionId::from_bytes([103; 32]),
+ delegated.input().grant_id(),
+ )
+ .await
+ .unwrap(),
+ );
+ let minimum = before.with_authorization(receipt.authorization());
+ // Restoring just the old encrypted grant is caught by the protected root's
+ // grant-set digest, even with a syntactically valid authentic envelope.
+ sqlx::query("UPDATE stock_grants SET protected=? WHERE grant_id=?")
+ .bind(old_grant)
+ .bind(delegated.input().grant_id().as_bytes().as_slice())
+ .execute(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(
+ store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await,
+ Err(WorkspaceError::RecoveryRequired)
+ );
+ connection.close().await.unwrap();
+ store.close().await.unwrap();
+ std::fs::copy(&backup, &original).unwrap();
+ let restored = NativeWorkspace::open_seller_stock(
+ &f.path,
+ enrollment.input().clone(),
+ f.crypto(),
+ f.clock.clone(),
+ )
+ .await
+ .unwrap();
+ let binding = restored
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ assert_eq!(
+ restored
+ .pool(
+ binding,
+ minimum,
+ PoolId::from_bytes([102; 32]),
+ proof(enrollment.proof())
+ )
+ .await,
+ Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint))
+ );
+ restored.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn grant_mutation_faults_roll_back_all_rows_and_original_transaction_replays() {
+ for table in ["stock_grants", "stock_grant_changes", "stock_authority"] {
+ let f = Fixture::new();
+ let (store, enrollment, owner) = create(&f).await;
+ let current = minimum(&owner);
+ let delegated = StockGrantEnrollment::prepare(
+ &SellerAuthoritySelection::from_attachment(owner.input()),
+ "fault-device".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ let mut connection = database(&f).await;
+ let sql = match table {
+ "stock_grants" => {
+ "CREATE TRIGGER grant_fault BEFORE INSERT ON stock_grants BEGIN SELECT RAISE(ABORT,'synthetic grant failure'); END"
+ }
+ "stock_grant_changes" => {
+ "CREATE TRIGGER grant_fault BEFORE INSERT ON stock_grant_changes BEGIN SELECT RAISE(ABORT,'synthetic grant failure'); END"
+ }
+ "stock_authority" => {
+ "CREATE TRIGGER grant_fault BEFORE UPDATE ON stock_authority BEGIN SELECT RAISE(ABORT,'synthetic grant failure'); END"
+ }
+ _ => unreachable!(),
+ };
+ sqlx::raw_sql(sql).execute(&mut connection).await.unwrap();
+ assert_eq!(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &delegated)
+ .await,
+ Err(WorkspaceError::StorageFailure)
+ );
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grants")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(count, 1);
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grant_changes")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(count, 0);
+ assert_eq!(
+ checkpoint(&store, owner.input(), enrollment.proof()).await,
+ current
+ );
+ sqlx::raw_sql("DROP TRIGGER grant_fault")
+ .execute(&mut connection)
+ .await
+ .unwrap();
+ let first = grant_committed(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &delegated)
+ .await
+ .unwrap(),
+ );
+ // Exact original identity and pre-state recover a successful attempt,
+ // including a lost response, without installing another grant or row.
+ let second = grant_committed(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &delegated)
+ .await
+ .unwrap(),
+ );
+ assert_eq!(first, second);
+ assert_eq!(first.transaction_id(), delegated.transaction_id());
+ let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grant_changes")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(count, 1);
+ connection.close().await.unwrap();
+ store.close().await.unwrap();
+ }
+}
+
+#[tokio::test]
+async fn unknown_grant_commit_fences_the_worker_and_reopen_recovers_the_original_prepared_identity()
+{
+ let f = Fixture::new();
+ let (store, enrollment, owner) = create(&f).await;
+ let current = minimum(&owner);
+ let delegated = StockGrantEnrollment::prepare(
+ &SellerAuthoritySelection::from_attachment(owner.input()),
+ "unknown-device".into(),
+ UnixSeconds::new(200).unwrap(),
+ StockGrantScope::full_inventory(),
+ )
+ .unwrap();
+ let mut connection = database(&f).await;
+ sqlx::raw_sql("CREATE TABLE grant_commit_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER grant_commit_failure AFTER INSERT ON stock_grant_changes BEGIN INSERT INTO grant_commit_fault VALUES(2); END").execute(&mut connection).await.unwrap();
+ assert_eq!(
+ store
+ .enroll_stock_grant(owner.clone(), current, enrollment.proof(), &delegated)
+ .await
+ .unwrap(),
+ StockGrantOutcome::Unknown(delegated.transaction_id())
+ );
+ assert_eq!(
+ store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await,
+ Err(WorkspaceError::RecoveryRequired)
+ );
+ store.close().await.unwrap();
+ sqlx::raw_sql("DROP TRIGGER grant_commit_failure; DROP TABLE grant_commit_fault")
+ .execute(&mut connection)
+ .await
+ .unwrap();
+ connection.close().await.unwrap();
+ let reopened = NativeWorkspace::open_seller_stock(
+ &f.path,
+ enrollment.input().clone(),
+ f.crypto(),
+ f.clock.clone(),
+ )
+ .await
+ .unwrap();
+ let binding = reopened
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ assert_eq!(
+ checkpoint(&reopened, binding.input(), enrollment.proof()).await,
+ current
+ );
+ let result = grant_committed(
+ reopened
+ .enroll_stock_grant(binding, current, enrollment.proof(), &delegated)
+ .await
+ .unwrap(),
+ );
+ assert_eq!(result.transaction_id(), delegated.transaction_id());
+ reopened.close().await.unwrap();
+}
diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs
@@ -95,7 +95,15 @@ struct LocalOutboxAuthority {
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
+struct StockCapabilityContract {
+ id: String,
+ version: String,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
struct NativeSellerStockAuthority {
+ capability_contract: StockCapabilityContract,
scope: String,
database: String,
lock: String,
@@ -105,6 +113,21 @@ struct NativeSellerStockAuthority {
authority_payload_schema: String,
inventory_operation_payload_schema: String,
inventory_movement_payload_schema: String,
+ grant_payload_schema: String,
+ grant_change_payload_schema: String,
+ namespace_excludes_caller_grant: bool,
+ actor_operation_unique_across_grants: bool,
+ grant_checkpoint_minimum_required: bool,
+ grant_checkpoint_policy: String,
+ grant_set_max: u16,
+ grant_pool_scope_max: u16,
+ grant_action_max: u16,
+ grant_scope_actions: Vec<String>,
+ grant_write_requires_receipt_and_recovery_read: bool,
+ inventory_scope_grants_administration: bool,
+ grant_admin_prepared_transaction_required: bool,
+ retained_grants_automatically_evicted: bool,
+ old_self_revoke_api_supported: bool,
pool_tick_scale_explicit: bool,
pool_tick_scale_encoding: String,
inventory_checkpoint_minimum_required: bool,
@@ -288,15 +311,41 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> {
)?;
let stock = &p.native_seller_stock_authority;
require(
- stock.scope == "seller_stock_owner"
+ stock.capability_contract.id == "radroots.seller_stock.native_inventory"
+ && stock.capability_contract.version == "1"
+ && stock.scope == "seller_stock_owner"
&& stock.database == "stock_execution_v1.sqlite"
&& stock.lock == ".stock_execution_v1.lock"
- && stock.schema_version == 3
+ && stock.schema_version == 4
&& stock.retained_enrollment_versions == [1]
- && stock.retained_inventory_versions == [2]
- && stock.authority_payload_schema == "radroots.seller_stock.authority.v3"
- && stock.inventory_operation_payload_schema == "radroots.seller_stock.operation.v2"
+ && stock.retained_inventory_versions == [2, 3]
+ && stock.authority_payload_schema == "radroots.seller_stock.authority.v4"
+ && stock.inventory_operation_payload_schema == "radroots.seller_stock.operation.v3"
&& stock.inventory_movement_payload_schema == "radroots.seller_stock.movement.v2"
+ && stock.grant_payload_schema == "radroots.seller_stock.grant.v2"
+ && stock.grant_change_payload_schema == "radroots.seller_stock.grant_change.v1"
+ && stock.namespace_excludes_caller_grant
+ && stock.actor_operation_unique_across_grants
+ && stock.grant_checkpoint_minimum_required
+ && stock.grant_checkpoint_policy
+ == "exact_current_for_fresh_work_original_prior_for_exact_admin_recovery"
+ && stock.grant_set_max == 64
+ && stock.grant_pool_scope_max == 64
+ && stock.grant_action_max == 6
+ && stock.grant_scope_actions
+ == [
+ "read_pools",
+ "read_operations",
+ "create_pool",
+ "add_stock",
+ "remove_stock",
+ "spoil_stock",
+ ]
+ && stock.grant_write_requires_receipt_and_recovery_read
+ && !stock.inventory_scope_grants_administration
+ && stock.grant_admin_prepared_transaction_required
+ && !stock.retained_grants_automatically_evicted
+ && !stock.old_self_revoke_api_supported
&& stock.pool_tick_scale_explicit
&& stock.pool_tick_scale_encoding == "canonical_integer_string"
&& stock.inventory_checkpoint_minimum_required