lib

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

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:
Mcontracts/api_baselines/radroots_storage.txt | 90+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcontracts/api_baselines/radroots_storage_sqlite.txt | 19+++++++++++++++++++
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 48+++++++++++++++++++++++++++++++++++++++++-------
Mcrates/storage/src/inventory.rs | 61+++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
Mcrates/storage/src/workspace.rs | 20++++++++++++++++++++
Mcrates/storage/src/workspace/grant.rs | 6++++++
Mcrates/storage/src/workspace/seller_stock.rs | 6++++++
Acrates/storage/src/workspace/seller_stock/authorization.rs | 195+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage/src/workspace/seller_stock/permissions.rs | 254+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage/src/workspace/seller_stock/selection.rs | 193+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage/tests/workspace.rs | 215+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/crypto.rs | 38++++++++++++++++++++++++++++++++++++--
Mcrates/storage_sqlite/src/workspace/mod.rs | 5++++-
Mcrates/storage_sqlite/src/workspace/stock.rs | 142++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
Acrates/storage_sqlite/src/workspace/stock/grants.rs | 577+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/inventory.rs | 167++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
Mcrates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs | 6+++---
Mcrates/storage_sqlite/src/workspace/stock/inventory/codec.rs | 49+++++++++++++++++++++++++++++++++++++++++++++++--
Mcrates/storage_sqlite/src/workspace/stock/inventory/plan.rs | 2+-
Mcrates/storage_sqlite/src/workspace/stock/schema.rs | 14++++++++++++--
Mcrates/storage_sqlite/src/workspace/stock/tests.rs | 295++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
Mcrates/storage_sqlite/src/workspace/worker.rs | 43++++++++++++++++++++++++++++++++++++++++++-
Mcrates/storage_sqlite/tests/support/pool_creation.rs | 19++++++++++++++++++-
Mcrates/storage_sqlite/tests/support/stock_authority.rs | 62++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
Acrates/storage_sqlite/tests/support/stock_grants.rs | 802+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mtools/xtask/src/architecture/decision_package.rs | 59++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
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, &current) + .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, + &current, + 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, &current)?; + 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,&current)?; - 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, &current) + .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, &current).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, + &current + ) + .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