lib

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

commit cc96f676e863d23a3f323a8803e3f6cc2cb38414
parent a4cc1a1cc76c7e313b0304eb321561e0af14ae22
Author: triesap <tyson@radroots.org>
Date:   Sat, 24 Oct 2026 20:36:56 +0000

storage_sqlite: commit owner-private pool creation atomically

- Capture explicit pool precision and independently verified command digests.
- Retain protected pool, original effect, movement and checkpoint together.
- Reject acknowledged rollback and reconcile unknown transaction outcomes.
- Verify native and Linux faults, retained catalogs and browser boundaries.

Diffstat:
Mcontracts/api_baselines/radroots_domain.txt | 25+++++++++++++++++++++++++
Mcontracts/api_baselines/radroots_protocol.txt | 21+++++++++++++++++++++
Mcontracts/api_baselines/radroots_storage.txt | 31+++++++++++++++++++++++++++++++
Mcontracts/api_baselines/radroots_storage_sqlite.txt | 5+++++
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 8+++++++-
Mcrates/domain/src/listing.rs | 24++++++++++++++++++++++++
Mcrates/domain/src/stock.rs | 36++++++++++++++++++++++++++++++++++++
Acrates/domain/src/stock/serialization.rs | 151++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/domain/tests/stock.rs | 106+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/protocol/src/command.rs | 2++
Acrates/protocol/src/command/stock.rs | 200+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/protocol/tests/fixtures/pool_creation.v1.json | 36++++++++++++++++++++++++++++++++++++
Acrates/protocol/tests/pool_creation.rs | 157+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage/src/inventory.rs | 191+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage/src/lib.rs | 2++
Mcrates/storage_sqlite/README.md | 36++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/crypto.rs | 106+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock.rs | 231++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------
Acrates/storage_sqlite/src/workspace/stock/inventory.rs | 877+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/schema.rs | 86+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/tests.rs | 130+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/tests/mod.rs | 11+++++++----
Mcrates/storage_sqlite/src/workspace/worker.rs | 139+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/tests/support/pool_creation.rs | 935+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/tests/support/stock_authority.rs | 2+-
Mcrates/storage_sqlite/tests/workspace_attachment.rs | 3+++
Mtools/xtask/src/architecture/decision_package.rs | 14+++++++++++++-
27 files changed, 3520 insertions(+), 45 deletions(-)

diff --git a/contracts/api_baselines/radroots_domain.txt b/contracts/api_baselines/radroots_domain.txt @@ -32,6 +32,8 @@ pub radroots_domain::listing::MeasurementUnit::Litre pub radroots_domain::listing::MeasurementUnit::Millilitre impl radroots_domain::listing::MeasurementUnit pub const fn radroots_domain::listing::MeasurementUnit::symbol(self) -> &'static str +impl<'de> serde_core::de::Deserialize<'de> for radroots_domain::listing::MeasurementUnit +pub fn radroots_domain::listing::MeasurementUnit::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> #[non_exhaustive] pub enum radroots_domain::listing::Price pub radroots_domain::listing::Price::Fixed(radroots_domain::FixedPrice) pub radroots_domain::listing::Price::QuoteRequired @@ -183,6 +185,10 @@ impl radroots_domain::stock::PhysicalBalances pub const radroots_domain::stock::PhysicalBalances::ZERO: Self impl core::fmt::Debug for radroots_domain::stock::PhysicalBalances pub fn radroots_domain::stock::PhysicalBalances::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl serde_core::ser::Serialize for radroots_domain::stock::PhysicalBalances +pub fn radroots_domain::stock::PhysicalBalances::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_domain::stock::PhysicalBalances +pub fn radroots_domain::stock::PhysicalBalances::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> pub struct radroots_domain::stock::PoolBalances impl radroots_domain::stock::PoolBalances pub const fn radroots_domain::stock::PoolBalances::introduced(self) -> radroots_domain::stock::StockTicks @@ -190,6 +196,10 @@ pub fn radroots_domain::stock::PoolBalances::new(radroots_domain::stock::StockTi pub const fn radroots_domain::stock::PoolBalances::physical(self) -> radroots_domain::stock::PhysicalBalances impl core::fmt::Debug for radroots_domain::stock::PoolBalances pub fn radroots_domain::stock::PoolBalances::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl serde_core::ser::Serialize for radroots_domain::stock::PoolBalances +pub fn radroots_domain::stock::PoolBalances::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_domain::stock::PoolBalances +pub fn radroots_domain::stock::PoolBalances::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> pub struct radroots_domain::stock::PoolSnapshot impl radroots_domain::stock::PoolSnapshot pub const fn radroots_domain::stock::PoolSnapshot::balances(self) -> radroots_domain::stock::PoolBalances @@ -199,12 +209,27 @@ pub const fn radroots_domain::stock::PoolSnapshot::unit(self) -> radroots_domain pub const fn radroots_domain::stock::PoolSnapshot::version(self) -> radroots_domain::Sequence impl core::fmt::Debug for radroots_domain::stock::PoolSnapshot pub fn radroots_domain::stock::PoolSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl serde_core::ser::Serialize for radroots_domain::stock::PoolSnapshot +pub fn radroots_domain::stock::PoolSnapshot::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_domain::stock::PoolSnapshot +pub fn radroots_domain::stock::PoolSnapshot::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> pub struct radroots_domain::stock::PoolUnit impl radroots_domain::stock::PoolUnit pub const fn radroots_domain::stock::PoolUnit::new(radroots_domain::listing::MeasurementUnit, u8) -> core::result::Result<Self, radroots_domain::stock::StockError> pub const fn radroots_domain::stock::PoolUnit::scale(self) -> u8 pub fn radroots_domain::stock::PoolUnit::ticks_for(self, radroots_domain::Quantity) -> core::result::Result<radroots_domain::stock::StockTicks, radroots_domain::stock::StockError> pub const fn radroots_domain::stock::PoolUnit::unit(self) -> radroots_domain::listing::MeasurementUnit +impl serde_core::ser::Serialize for radroots_domain::stock::PoolUnit +pub fn radroots_domain::stock::PoolUnit::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_domain::stock::PoolUnit +pub fn radroots_domain::stock::PoolUnit::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> +pub struct radroots_domain::stock::PoolView +impl radroots_domain::stock::PoolView +pub fn radroots_domain::stock::PoolView::label(&self) -> &str +pub fn radroots_domain::stock::PoolView::new(&str, radroots_domain::stock::PoolSnapshot) -> core::result::Result<Self, radroots_domain::stock::StockError> +pub const fn radroots_domain::stock::PoolView::snapshot(&self) -> radroots_domain::stock::PoolSnapshot +impl core::fmt::Debug for radroots_domain::stock::PoolView +pub fn radroots_domain::stock::PoolView::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_domain::stock::StockTicks(_) impl radroots_domain::stock::StockTicks pub const radroots_domain::stock::StockTicks::MAX: Self diff --git a/contracts/api_baselines/radroots_protocol.txt b/contracts/api_baselines/radroots_protocol.txt @@ -215,6 +215,27 @@ impl core::convert::From<radroots_protocol::command::CapturedChatCommand> for ra pub fn radroots_protocol::command::CapturedCommand::from(radroots_protocol::command::CapturedChatCommand) -> Self impl core::fmt::Debug for radroots_protocol::command::CapturedChatCommand pub fn radroots_protocol::command::CapturedChatCommand::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_protocol::command::CapturedPoolCreation +impl radroots_protocol::command::CapturedPoolCreation +pub const fn radroots_protocol::command::CapturedPoolCreation::approval_intent_digest(&self) -> radroots_domain::identifier::ApprovalIntentDigest +pub const fn radroots_protocol::command::CapturedPoolCreation::context(&self) -> &radroots_domain::context::CommandContextData +pub const fn radroots_protocol::command::CapturedPoolCreation::digest(&self) -> radroots_domain::identifier::CommandDigest +pub const fn radroots_protocol::command::CapturedPoolCreation::input(&self) -> &radroots_protocol::command::CreatePoolInput +pub fn radroots_protocol::command::CapturedPoolCreation::new(radroots_domain::context::CommandContextData, radroots_protocol::command::CreatePoolInput) -> core::result::Result<Self, radroots_protocol::command::CommandError> +pub fn radroots_protocol::command::CapturedPoolCreation::parse(&[u8]) -> core::result::Result<Self, radroots_protocol::command::CommandError> +pub fn radroots_protocol::command::CapturedPoolCreation::protected_wire(&self) -> &[u8] +impl core::fmt::Debug for radroots_protocol::command::CapturedPoolCreation +pub fn radroots_protocol::command::CapturedPoolCreation::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_protocol::command::CreatePoolInput +impl radroots_protocol::command::CreatePoolInput +pub const fn radroots_protocol::command::CreatePoolInput::id(&self) -> radroots_domain::identifier::PoolId +pub const fn radroots_protocol::command::CreatePoolInput::initial_ticks(&self) -> radroots_domain::stock::StockTicks +pub fn radroots_protocol::command::CreatePoolInput::label(&self) -> &str +pub fn radroots_protocol::command::CreatePoolInput::new(radroots_domain::identifier::PoolId, &str, radroots_domain::stock::PoolUnit, radroots_domain::quantity::Quantity) -> core::result::Result<Self, radroots_protocol::command::CommandError> +pub const fn radroots_protocol::command::CreatePoolInput::quantity(&self) -> radroots_domain::quantity::Quantity +pub const fn radroots_protocol::command::CreatePoolInput::unit(&self) -> radroots_domain::stock::PoolUnit +impl core::fmt::Debug for radroots_protocol::command::CreatePoolInput +pub fn radroots_protocol::command::CreatePoolInput::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_protocol::command::InquireInput impl radroots_protocol::command::InquireInput pub fn radroots_protocol::command::InquireInput::new(radroots_domain::identifier::ThreadId, radroots_identity::key::PublicKey, core::option::Option<radroots_protocol::command::ListingRevisionRef>, &str) -> core::result::Result<Self, radroots_protocol::command::CommandError> diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -1363,6 +1363,37 @@ pub fn radroots_storage::memory::MemoryStorage::rebuild_visibility(&self) -> rad pub fn radroots_storage::memory::MemoryStorage::source_token(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::event::EventSourceToken, radroots_storage::Error>> pub fn radroots_storage::memory::MemoryStorage::status(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::status::EventStoreStatus, radroots_storage::Error>> pub type radroots_storage::event::EventCursor = radroots_storage::event::EventPosition +pub mod radroots_storage::inventory +pub enum radroots_storage::inventory::PoolCreationOutcome +pub radroots_storage::inventory::PoolCreationOutcome::Committed(alloc::boxed::Box<radroots_storage::inventory::PoolCreationReceipt>) +pub radroots_storage::inventory::PoolCreationOutcome::Unknown(radroots_storage::command::CommitAttempt) +pub struct radroots_storage::inventory::CreatePoolRequest +impl radroots_storage::inventory::CreatePoolRequest +pub const fn radroots_storage::inventory::CreatePoolRequest::binding(&self) -> &radroots_storage::workspace::WorkspaceBinding +pub const fn radroots_storage::inventory::CreatePoolRequest::command(&self) -> &radroots_protocol::command::stock::CapturedPoolCreation +pub fn radroots_storage::inventory::CreatePoolRequest::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::CreatePoolRequest::minimum_checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub fn radroots_storage::inventory::CreatePoolRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock::CapturedPoolCreation) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::inventory::CreatePoolRequest::retained_copy(&self) -> core::result::Result<Self, radroots_storage::command::OperationError> +impl core::fmt::Debug for radroots_storage::inventory::CreatePoolRequest +pub fn radroots_storage::inventory::CreatePoolRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +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 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 struct radroots_storage::inventory::PoolCreationReceipt +impl radroots_storage::inventory::PoolCreationReceipt +pub const fn radroots_storage::inventory::PoolCreationReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt +pub const fn radroots_storage::inventory::PoolCreationReceipt::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub fn radroots_storage::inventory::PoolCreationReceipt::from_committed_store(radroots_storage::command::CommitAttempt, radroots_domain::stock::PoolSnapshot, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::inventory::PoolCreationReceipt::pool(&self) -> radroots_domain::stock::PoolSnapshot +pub const fn radroots_storage::inventory::PoolCreationReceipt::transaction_id(&self) -> core::option::Option<radroots_domain::identifier::TransactionId> +pub trait radroots_storage::inventory::InventoryStore: radroots_storage::workspace::WorkspaceStore +pub fn radroots_storage::inventory::InventoryStore::create_pool(&self, radroots_storage::inventory::CreatePoolRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::PoolCreationOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::pool_creation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::PoolCreationReceipt>, radroots_storage::command::OperationError>> pub mod radroots_storage::journal pub use radroots_storage::journal::BoxFuture pub use radroots_storage::journal::EventId diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -397,12 +397,17 @@ pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_unknown<'a pub fn radroots_storage_sqlite::workspace::NativeWorkspace::record_delivery_observation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::AttachmentProof, radroots_storage::command::observation::DeliveryObservation) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::observation::DeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::signing_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::issuance::SigningAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::signing_plan(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::BoundSigningPlan>, radroots_storage::command::OperationError>> +impl radroots_storage::inventory::InventoryStore for radroots_storage_sqlite::workspace::NativeWorkspace +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::create_pool(&self, radroots_storage::inventory::CreatePoolRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::PoolCreationOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::pool_creation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::PoolCreationReceipt>, radroots_storage::command::OperationError>> impl radroots_storage::workspace::WorkspaceStore for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::close_workspace(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<(), radroots_storage::workspace::WorkspaceError>> pub struct radroots_storage_sqlite::workspace::StockAuthorityReceipt impl radroots_storage_sqlite::workspace::StockAuthorityReceipt pub fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::input(&self) -> &radroots_storage::workspace::AttachmentInput +pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::inventory_checkpoint(&self) -> core::option::Option<radroots_storage::inventory::InventoryCheckpointRef> pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::revocation_generation(&self) -> radroots_domain::context::Sequence pub const fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId pub struct radroots_storage_sqlite::workspace::StockEnrollment diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -72,7 +72,13 @@ "scope": "seller_stock_owner", "database": "stock_execution_v1.sqlite", "lock": ".stock_execution_v1.lock", - "schema_version": 1, + "schema_version": 2, + "retained_enrollment_versions": [1], + "authority_payload_schema": "radroots.seller_stock.authority.v2", + "pool_tick_scale_explicit": true, + "pool_tick_scale_encoding": "canonical_integer_string", + "inventory_checkpoint_minimum_required": true, + "empty_pool_has_physical_movement": false, "enrollment_prepared_before_durable_creation": true, "prepared_enrollment_single_use": true, "same_connection_owner_as_outbox": true, diff --git a/crates/domain/src/listing.rs b/crates/domain/src/listing.rs @@ -198,6 +198,30 @@ impl MeasurementUnit { } } +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MeasurementUnit { + fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + struct Visitor; + impl serde::de::Visitor<'_> for Visitor { + type Value = MeasurementUnit; + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("one exact measurement unit symbol") + } + fn visit_str<E: serde::de::Error>(self, value: &str) -> Result<MeasurementUnit, E> { + match value { + "g" => Ok(MeasurementUnit::Gram), + "kg" => Ok(MeasurementUnit::Kilogram), + "mL" => Ok(MeasurementUnit::Millilitre), + "L" => Ok(MeasurementUnit::Litre), + "each" => Ok(MeasurementUnit::Each), + _ => Err(E::custom("invalid measurement unit")), + } + } + } + deserializer.deserialize_str(Visitor) + } +} + #[derive(Clone, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize))] #[cfg_attr(feature = "serde", serde(tag = "type", rename_all = "snake_case"))] diff --git a/crates/domain/src/stock.rs b/crates/domain/src/stock.rs @@ -291,3 +291,39 @@ impl fmt::Debug for PoolSnapshot { f.write_str("PoolSnapshot(<redacted>)") } } + +#[cfg(feature = "serde")] +mod serialization; + +/// Bounded owner-private pool metadata and its physical snapshot claim. +/// This view grants no authority and is not independent proof of availability. +#[derive(Clone, Eq, PartialEq)] +pub struct PoolView { + label: zeroize::Zeroizing<alloc::string::String>, + snapshot: PoolSnapshot, +} +impl PoolView { + /// Preserves a plain bounded label without normalization or hidden defaults. + pub fn new(label: &str, snapshot: PoolSnapshot) -> Result<Self, StockError> { + if label.len() > 160 || label.chars().any(char::is_control) { + return Err(StockError::InvalidFormat); + } + Ok(Self { + label: zeroize::Zeroizing::new(alloc::string::String::from(label)), + snapshot, + }) + } + /// Borrows the exact owner-private label. + pub fn label(&self) -> &str { + &self.label + } + /// Returns the associated validated physical snapshot claim. + pub const fn snapshot(&self) -> PoolSnapshot { + self.snapshot + } +} +impl fmt::Debug for PoolView { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("PoolView(<redacted>)") + } +} diff --git a/crates/domain/src/stock/serialization.rs b/crates/domain/src/stock/serialization.rs @@ -0,0 +1,151 @@ +//! Closed value codecs. Successful decoding still proves no stock authority. +use super::{PhysicalBalances, PoolBalances, PoolSnapshot, PoolUnit, StockTicks}; +use crate::{PoolId, Sequence, listing::MeasurementUnit}; +use core::fmt; +use serde::{Deserialize, Deserializer, Serialize, Serializer, de}; + +#[derive(Clone, Copy)] +struct Scale(u8); +impl Serialize for Scale { + fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { + serializer.collect_str(&self.0) + } +} +impl<'de> Deserialize<'de> for Scale { + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + struct Visitor; + impl de::Visitor<'_> for Visitor { + type Value = Scale; + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("one canonical pool precision string from0 through6") + } + fn visit_str<E: de::Error>(self, value: &str) -> Result<Scale, E> { + match value.as_bytes() { + [byte @ b'0'..=b'6'] => Ok(Scale(byte - b'0')), + _ => Err(E::custom("invalid pool precision")), + } + } + } + deserializer.deserialize_str(Visitor) + } +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Unit { + unit: MeasurementUnit, + scale: Scale, +} +impl Serialize for PoolUnit { + fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { + Unit { + unit: self.unit(), + scale: Scale(self.scale()), + } + .serialize(serializer) + } +} +impl<'de> Deserialize<'de> for PoolUnit { + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + let wire: Unit = object(deserializer)?; + Self::new(wire.unit, wire.scale.0).map_err(de::Error::custom) + } +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Physical { + available: StockTicks, + preparatory_hold: StockTicks, + committed_hold: StockTicks, + physical_quarantine: StockTicks, + consumed: StockTicks, + waste: StockTicks, + removed: StockTicks, +} +impl Serialize for PhysicalBalances { + fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { + Physical { + available: self.available, + preparatory_hold: self.preparatory_hold, + committed_hold: self.committed_hold, + physical_quarantine: self.physical_quarantine, + consumed: self.consumed, + waste: self.waste, + removed: self.removed, + } + .serialize(serializer) + } +} +impl<'de> Deserialize<'de> for PhysicalBalances { + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + let v: Physical = object(deserializer)?; + Ok(Self { + available: v.available, + preparatory_hold: v.preparatory_hold, + committed_hold: v.committed_hold, + physical_quarantine: v.physical_quarantine, + consumed: v.consumed, + waste: v.waste, + removed: v.removed, + }) + } +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Balances { + introduced: StockTicks, + physical: PhysicalBalances, +} +impl Serialize for PoolBalances { + fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { + Balances { + introduced: self.introduced(), + physical: self.physical(), + } + .serialize(serializer) + } +} +impl<'de> Deserialize<'de> for PoolBalances { + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + let v: Balances = object(deserializer)?; + Self::new(v.introduced, v.physical).map_err(de::Error::custom) + } +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Snapshot { + id: PoolId, + unit: PoolUnit, + balances: PoolBalances, + version: Sequence, +} +impl Serialize for PoolSnapshot { + fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { + Snapshot { + id: self.id(), + unit: self.unit(), + balances: self.balances(), + version: self.version(), + } + .serialize(serializer) + } +} +impl<'de> Deserialize<'de> for PoolSnapshot { + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + let v: Snapshot = object(deserializer)?; + Ok(Self::new(v.id, v.unit, v.balances, v.version)) + } +} + +fn object<'de, D: Deserializer<'de>, T: Deserialize<'de>>(deserializer: 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 fmt::Formatter<'_>) -> fmt::Result { + f.write_str("a closed stock value object") + } + fn visit_map<A: de::MapAccess<'de>>(self, map: A) -> Result<T, A::Error> { + T::deserialize(de::value::MapAccessDeserializer::new(map)) + } + } + deserializer.deserialize_map(Visitor(core::marker::PhantomData)) +} diff --git a/crates/domain/tests/stock.rs b/crates/domain/tests/stock.rs @@ -252,3 +252,109 @@ fn foreign_tick_serialization_uses_exact_strings_and_rejects_json_numbers() { ); } } + +#[cfg(feature = "serde")] +#[test] +fn protected_projection_value_codec_is_lossless_and_checks_conservation() { + use serde_json::{Value, json}; + let amount = StockTicks::MAX; + let snapshot = PoolSnapshot::new( + PoolId::from_bytes([9; 32]), + PoolUnit::new(Kilogram, 6).unwrap(), + PoolBalances::new( + amount, + PhysicalBalances { + available: amount, + ..PhysicalBalances::ZERO + }, + ) + .unwrap(), + Sequence::new(i64::MAX as u64).unwrap(), + ); + let value = serde_json::to_value(snapshot).unwrap(); + assert_eq!(value["unit"], json!({"unit":"kg","scale":"6"})); + assert_eq!( + value["balances"]["introduced"], + json!("1000000000000000000") + ); + assert_eq!(value["version"], json!("9223372036854775807")); + assert_eq!( + serde_json::from_value::<PoolSnapshot>(value.clone()).unwrap(), + snapshot + ); + for (path, bad) in [ + ("/balances/physical/available", json!("999999999999999999")), + ("/balances/physical/available", json!("1000000000000000001")), + ("/balances/physical/available", json!(100)), + ("/balances/introduced", json!("-1")), + ("/version", json!("01")), + ("/unit/scale", json!(6)), + ("/unit/scale", json!("06")), + ("/unit/scale", json!("7")), + ("/unit/unit", json!("each")), + ("/unit", json!(["kg", "6"])), + ("/balances", json!(["1000000000000000000", {}])), + ( + "/balances/physical", + json!(["1000000000000000000", "0", "0", "0", "0", "0", "0"]), + ), + ] { + let mut changed = value.clone(); + *changed.pointer_mut(path).unwrap() = bad; + assert!( + serde_json::from_value::<PoolSnapshot>(changed).is_err(), + "{path}" + ); + } + for path in ["", "/unit", "/balances", "/balances/physical"] { + let mut changed = value.clone(); + changed + .pointer_mut(path) + .unwrap() + .as_object_mut() + .unwrap() + .insert("extra".into(), Value::Null); + assert!( + serde_json::from_value::<PoolSnapshot>(changed).is_err(), + "{path}" + ); + } + assert!( + serde_json::from_value::<PoolSnapshot>(json!([ + value["id"], + value["unit"], + value["balances"], + value["version"] + ])) + .is_err() + ); +} +#[cfg(feature = "serde")] +#[test] +fn unit_codecs_accept_only_exact_symbols_and_canonical_precision_strings() { + use serde_json::json; + for unit in [Gram, Kilogram, Millilitre, Litre, Each] { + for scale in 0..=6 { + if unit == Each && scale != 0 { + continue; + } + let value = PoolUnit::new(unit, scale).unwrap(); + assert_eq!( + serde_json::from_str::<PoolUnit>(&serde_json::to_string(&value).unwrap()).unwrap(), + value + ); + } + } + for symbol in [ + json!("ml"), + json!("l"), + json!("KG"), + json!("piece"), + json!({"g":null}), + json!(["g"]), + ] { + assert!( + serde_json::from_value::<radroots_domain::listing::MeasurementUnit>(symbol).is_err() + ); + } +} diff --git a/crates/protocol/src/command.rs b/crates/protocol/src/command.rs @@ -49,7 +49,9 @@ impl fmt::Display for CommandError { impl core::error::Error for CommandError {} mod captured; +mod stock; pub use captured::{CapturedCommand, CommandKind}; +pub use stock::{CapturedPoolCreation, CreatePoolInput}; /// A captured public listing reference. This descriptor verifies neither its /// source event nor its availability, terms or stock backing. diff --git a/crates/protocol/src/command/stock.rs b/crates/protocol/src/command/stock.rs @@ -0,0 +1,200 @@ +//! Exact owner-private pool creation data, without durable stock permission. +use super::{COMMAND_MAX_BYTES, CommandError, Context, check_frame, hash, parse_object}; +use alloc::{boxed::Box, string::String, vec::Vec}; +use core::fmt; +use radroots_domain::{ + ApprovalIntentDigest, CommandContextData, CommandDigest, Decimal, PoolId, Quantity, + listing::MeasurementUnit, + stock::{PoolUnit, StockTicks}, +}; +use serde::{Deserialize, Serialize, ser::SerializeStruct}; +use zeroize::Zeroizing; + +/// Fixed unit/precision and initial quantity. This is a claim, not inventory. +pub struct CreatePoolInput { + id: PoolId, + label: Zeroizing<String>, + unit: PoolUnit, + quantity: Quantity, + ticks: StockTicks, +} +impl CreatePoolInput { + pub fn new( + id: PoolId, + label: &str, + unit: PoolUnit, + quantity: Quantity, + ) -> Result<Self, CommandError> { + if label.len() > 160 { + return Err(CommandError::LimitExceeded); + } + if label.chars().any(char::is_control) { + return Err(CommandError::InvalidInput); + } + let ticks = unit + .ticks_for(quantity) + .map_err(|_| CommandError::InvalidInput)?; + Ok(Self { + id, + label: Zeroizing::new(String::from(label)), + unit, + quantity, + ticks, + }) + } + pub const fn id(&self) -> PoolId { + self.id + } + pub fn label(&self) -> &str { + &self.label + } + pub const fn unit(&self) -> PoolUnit { + self.unit + } + pub const fn quantity(&self) -> Quantity { + self.quantity + } + pub const fn initial_ticks(&self) -> StockTicks { + self.ticks + } +} +impl fmt::Debug for CreatePoolInput { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("CreatePoolInput(<redacted>)") + } +} +/// Complete bounded command commitment. No host or signer is acquired here. +pub struct CapturedPoolCreation { + context: CommandContextData, + input: CreatePoolInput, + wire: Zeroizing<Box<[u8]>>, + digest: CommandDigest, + approval: ApprovalIntentDigest, +} +impl CapturedPoolCreation { + pub fn new(context: CommandContextData, input: CreatePoolInput) -> Result<Self, CommandError> { + let encode = |approval, correlation| -> Result<Zeroizing<Vec<u8>>, CommandError> { + let bytes = Zeroizing::new( + serde_json::to_vec(&Wire { + context: &context, + input: &input, + approval, + correlation, + }) + .map_err(|_| CommandError::InvalidInput)?, + ); + if bytes.len() > COMMAND_MAX_BYTES { + return Err(CommandError::LimitExceeded); + } + Ok(bytes) + }; + let wire = Zeroizing::new(Box::from(encode(true, true)?.as_slice())); + let digest = + CommandDigest::from_bytes(hash(b"radroots.command.v1\0", &encode(true, false)?)); + let approval = ApprovalIntentDigest::from_bytes(hash( + b"radroots.approval.v1\0", + &encode(false, false)?, + )); + Ok(Self { + context, + input, + wire, + digest, + approval, + }) + } + pub fn parse(raw: &[u8]) -> Result<Self, CommandError> { + check_frame(raw)?; + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Root<'a> { + #[serde(rename = "type")] + kind: String, + context: CommandContextData, + #[serde(borrow)] + input: &'a serde_json::value::RawValue, + } + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Input { + id: PoolId, + label: String, + unit: MeasurementUnit, + tick_scale: String, + initial_quantity: Decimal, + } + let root: Root<'_> = parse_object(raw)?; + if root.kind != "stock.create_pool" { + return Err(CommandError::UnsupportedCommand); + } + let v: Input = parse_object(root.input.get().as_bytes())?; + let scale = match v.tick_scale.as_bytes() { + [byte @ b'0'..=b'6'] => *byte - b'0', + _ => return Err(CommandError::InvalidInput), + }; + let unit = PoolUnit::new(v.unit, scale).map_err(|_| CommandError::InvalidInput)?; + let quantity = + Quantity::new(v.initial_quantity, v.unit).map_err(|_| CommandError::InvalidInput)?; + Self::new( + root.context, + CreatePoolInput::new(v.id, &v.label, unit, quantity)?, + ) + } + pub const fn context(&self) -> &CommandContextData { + &self.context + } + pub const fn input(&self) -> &CreatePoolInput { + &self.input + } + pub fn protected_wire(&self) -> &[u8] { + &self.wire + } + pub const fn digest(&self) -> CommandDigest { + self.digest + } + pub const fn approval_intent_digest(&self) -> ApprovalIntentDigest { + self.approval + } +} +impl fmt::Debug for CapturedPoolCreation { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("CapturedPoolCreation(<redacted>)") + } +} +struct Wire<'a> { + context: &'a CommandContextData, + input: &'a CreatePoolInput, + approval: bool, + correlation: bool, +} +impl Serialize for Wire<'_> { + fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> { + let mut o = s.serialize_struct("PoolCreation", 3)?; + o.serialize_field( + "context", + &Context(self.context, self.approval, self.correlation), + )?; + o.serialize_field("input", &InputWire(self.input))?; + o.serialize_field("type", "stock.create_pool")?; + o.end() + } +} +struct Scale(u8); +impl Serialize for Scale { + fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> { + s.collect_str(&self.0) + } +} +struct InputWire<'a>(&'a CreatePoolInput); +impl Serialize for InputWire<'_> { + fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> { + let v = self.0; + let mut o = s.serialize_struct("CreatePoolInput", 5)?; + o.serialize_field("id", &v.id)?; + o.serialize_field("initial_quantity", &v.quantity.amount())?; + o.serialize_field("label", v.label())?; + o.serialize_field("tick_scale", &Scale(v.unit.scale()))?; + o.serialize_field("unit", &v.unit.unit())?; + o.end() + } +} diff --git a/crates/protocol/tests/fixtures/pool_creation.v1.json b/crates/protocol/tests/fixtures/pool_creation.v1.json @@ -0,0 +1,36 @@ +{ + "provenance": "Synthetic complete pool creation case; independently encoded with Python json sorted ASCII keys, UTF-8 strings, compact separators, no numeric JSON values. SHA-256 uses the specified command/approval domain plus NUL. This is the applicable RFC8785 subset, not a general Python JCS implementation.", + "oracle_python": "3.14.7 (main, Sep 29 2026, 14:50:11) [Clang 22.1.3 ]", + "wire": { + "type": "stock.create_pool", + "context": { + "actor": { + "grant_id": "0303030303030303030303030303030303030303030303030303030303030303", + "organization": null, + "participant": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", + "role": "seller" + }, + "approval": null, + "authority": { + "executor_id": "0202020202020202020202020202020202020202020202020202020202020202", + "generation": "1" + }, + "correlation_id": null, + "expected": null, + "not_after": "200", + "operation_id": "0707070707070707070707070707070707070707070707070707070707070707", + "route_digest": "0606060606060606060606060606060606060606060606060606060606060606", + "workspace_id": "0101010101010101010101010101010101010101010101010101010101010101" + }, + "input": { + "id": "0808080808080808080808080808080808080808080808080808080808080808", + "initial_quantity": "0.25", + "label": "Carrots", + "tick_scale": "3", + "unit": "kg" + } + }, + "semantic_canonical_utf8": "{\"context\":{\"actor\":{\"grant_id\":\"0303030303030303030303030303030303030303030303030303030303030303\",\"organization\":null,\"participant\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"role\":\"seller\"},\"approval\":null,\"authority\":{\"executor_id\":\"0202020202020202020202020202020202020202020202020202020202020202\",\"generation\":\"1\"},\"expected\":null,\"not_after\":\"200\",\"operation_id\":\"0707070707070707070707070707070707070707070707070707070707070707\",\"route_digest\":\"0606060606060606060606060606060606060606060606060606060606060606\",\"workspace_id\":\"0101010101010101010101010101010101010101010101010101010101010101\"},\"input\":{\"id\":\"0808080808080808080808080808080808080808080808080808080808080808\",\"initial_quantity\":\"0.25\",\"label\":\"Carrots\",\"tick_scale\":\"3\",\"unit\":\"kg\"},\"type\":\"stock.create_pool\"}", + "command_digest": "a3642eaff89d48ca90b7cfe664a6da5b18976bb0307dbb7428676e73513712a1", + "approval_intent_digest": "63cf866a25c886ea9dc914f074dc0962c4cee5bc228d1fb02f81b7dfb5a335b5" +} diff --git a/crates/protocol/tests/pool_creation.rs b/crates/protocol/tests/pool_creation.rs @@ -0,0 +1,157 @@ +#![cfg(feature = "commands")] +use radroots_domain::{ + ActorRef, ActorRole, AuthorityRef, CommandContextData, CorrelationId, Decimal, ExecutorId, + Generation, GrantId, OperationId, PoolId, PublicKey, Quantity, RouteDigest, UnixSeconds, + WorkspaceId, listing::MeasurementUnit, stock::PoolUnit, +}; +use radroots_protocol::command::{CapturedPoolCreation, CreatePoolInput}; +use serde_json::json; +fn context(correlation: Option<&str>) -> CommandContextData { + let key = + PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798") + .unwrap(); + CommandContextData::new( + OperationId::from_bytes([7; 32]), + ActorRef::new( + key, + ActorRole::Seller, + None, + Some(GrantId::from_bytes([3; 32])), + ), + WorkspaceId::from_bytes([1; 32]), + AuthorityRef::new(ExecutorId::from_bytes([2; 32]), Generation::new(1).unwrap()), + RouteDigest::from_bytes([6; 32]), + None, + None, + UnixSeconds::new(200).unwrap(), + correlation.map(|s| CorrelationId::new(s).unwrap()), + ) + .unwrap() +} +fn capture(scale: u8, correlation: Option<&str>) -> CapturedPoolCreation { + let unit = PoolUnit::new(MeasurementUnit::Kilogram, scale).unwrap(); + let quantity = Quantity::new( + "0.25".parse::<Decimal>().unwrap(), + MeasurementUnit::Kilogram, + ) + .unwrap(); + CapturedPoolCreation::new( + context(correlation), + CreatePoolInput::new(PoolId::from_bytes([8; 32]), "Carrots", unit, quantity).unwrap(), + ) + .unwrap() +} +#[test] +fn exact_pool_capture_binds_precision_and_excludes_only_diagnostic_correlation() { + let original = capture(3, None); + let parsed = CapturedPoolCreation::parse(original.protected_wire()).unwrap(); + assert_eq!(parsed.digest(), original.digest()); + assert_eq!(parsed.protected_wire(), original.protected_wire()); + assert_eq!(parsed.input().initial_ticks().get(), 250); + let correlated = capture(3, Some("display-only")); + assert_eq!(original.digest(), correlated.digest()); + assert_ne!(original.protected_wire(), correlated.protected_wire()); + let finer = capture(4, None); + assert_ne!(original.digest(), finer.digest()); + assert_eq!(finer.input().initial_ticks().get(), 2500); + let value: serde_json::Value = serde_json::from_slice(original.protected_wire()).unwrap(); + assert_eq!(value["input"]["tick_scale"], json!("3")); + assert_eq!(value["input"]["initial_quantity"], json!("0.25")); +} +#[test] +fn malformed_or_implicit_pool_precision_and_unknown_shapes_are_refused() { + let original = capture(3, None); + let base: serde_json::Value = serde_json::from_slice(original.protected_wire()).unwrap(); + for (path, bad) in [ + ("/input/tick_scale", json!(3)), + ("/input/tick_scale", json!("03")), + ("/input/tick_scale", json!("7")), + ("/input/tick_scale", json!("1")), + ("/input/unit", json!("each")), + ("/input/unit", json!({"kg":null})), + ("/input/initial_quantity", json!(0.25)), + ("/input/initial_quantity", json!("0.250")), + ("/input/id", json!("F".repeat(64))), + ] { + let mut v = base.clone(); + *v.pointer_mut(path).unwrap() = bad; + assert!( + CapturedPoolCreation::parse(&serde_json::to_vec(&v).unwrap()).is_err(), + "{path}" + ); + } + for field in ["tick_scale", "unit", "label", "initial_quantity", "id"] { + let mut v = base.clone(); + v["input"].as_object_mut().unwrap().remove(field); + assert!( + CapturedPoolCreation::parse(&serde_json::to_vec(&v).unwrap()).is_err(), + "{field}" + ); + } + for path in ["", "/input"] { + let mut v = base.clone(); + v.pointer_mut(path) + .unwrap() + .as_object_mut() + .unwrap() + .insert("ignored".into(), json!(true)); + assert!(CapturedPoolCreation::parse(&serde_json::to_vec(&v).unwrap()).is_err()); + } + assert!( + CapturedPoolCreation::parse( + &serde_json::to_vec(&json!([base["type"], base["context"], base["input"]])).unwrap() + ) + .is_err() + ); +} +#[test] +fn typed_creation_never_converts_units_rounds_quantities_or_copies_oversized_labels() { + let unit = PoolUnit::new(MeasurementUnit::Kilogram, 3).unwrap(); + let other = Quantity::new(Decimal::ONE, MeasurementUnit::Gram).unwrap(); + assert!(CreatePoolInput::new(PoolId::from_bytes([1; 32]), "x", unit, other).is_err()); + let quantity = Quantity::new(Decimal::ONE, MeasurementUnit::Kilogram).unwrap(); + assert!( + CreatePoolInput::new( + PoolId::from_bytes([1; 32]), + &"a".repeat(161), + unit, + quantity + ) + .is_err() + ); + assert!( + CreatePoolInput::new(PoolId::from_bytes([1; 32]), "hidden\nlabel", unit, quantity).is_err() + ); +} + +#[test] +fn complete_pool_command_matches_independent_canonical_hash_vector() { + let fixture: serde_json::Value = + serde_json::from_str(include_str!("fixtures/pool_creation.v1.json")).unwrap(); + let captured = + CapturedPoolCreation::parse(&serde_json::to_vec(&fixture["wire"]).unwrap()).unwrap(); + assert_eq!( + captured.digest().to_string(), + fixture["command_digest"].as_str().unwrap() + ); + assert_eq!( + captured.approval_intent_digest().to_string(), + fixture["approval_intent_digest"].as_str().unwrap() + ); + for (path, value) in [ + ("/context/authority/generation", json!("2")), + ("/context/actor/grant_id", json!("09".repeat(32))), + ("/context/not_after", json!("201")), + ("/context/route_digest", json!("09".repeat(32))), + ("/context/workspace_id", json!("09".repeat(32))), + ("/input/unit", json!("g")), + ("/input/label", json!("カブ 🥕")), + ("/input/initial_quantity", json!("0.5")), + ("/input/tick_scale", json!("4")), + ] { + let mut changed = fixture["wire"].clone(); + *changed.pointer_mut(path).unwrap() = value; + let changed = CapturedPoolCreation::parse(&serde_json::to_vec(&changed).unwrap()).unwrap(); + assert_ne!(changed.digest(), captured.digest(), "{path}"); + } +} diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs @@ -0,0 +1,191 @@ +//! Typed owner-private stock transactions. Values and receipt construction +//! establish no authority or durable effect; concrete qualified hosts do that. +use crate::{ + command::{CommitAttempt, OperationError}, + workspace::{AttachmentProof, WorkspaceBinding, WorkspaceScope, WorkspaceStore}, +}; +use radroots_domain::{CommandDigest, OperationId, PoolId, TransactionId, stock::PoolSnapshot}; +use radroots_protocol::command::CapturedPoolCreation; +use radroots_transport::BoxFuture; + +/// Exact captured owner-private creation and original authenticated observation. +pub struct CreatePoolRequest { + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + command: CapturedPoolCreation, +} +impl CreatePoolRequest { + pub fn new( + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + command: CapturedPoolCreation, + ) -> 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() + || context.authority() != selection.authority() + || context.route_digest() != selection.route_digest() + || context.actor() != binding.actor() + { + return Err(OperationError::InvalidCommand); + } + if context.expected().is_some() { + return Err(OperationError::MissingHistory); + } + if context.approval().is_some() { + return Err(OperationError::UnverifiedApproval); + } + if command.protected_wire().len() > 16 * 1024 { + return Err(OperationError::InvalidCommand); + } + if minimum.authority() != selection.authority() { + return Err(crate::workspace::WorkspaceError::StaleAuthority.into()); + } + Ok(Self { + binding, + minimum, + command, + }) + } + /// Reconstructs captured data only; the concrete host must reauthenticate it. + pub fn from_protected_wire( + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + wire: &[u8], + ) -> Result<Self, OperationError> { + Self::new( + binding, + minimum, + CapturedPoolCreation::parse(wire).map_err(|_| OperationError::RecoveryRequired)?, + ) + } + /// Independently retained acknowledged minimum, never guessed from a cache. + pub const fn minimum_checkpoint(&self) -> InventoryCheckpointRef { + self.minimum + } + pub const fn binding(&self) -> &WorkspaceBinding { + &self.binding + } + pub const fn command(&self) -> &CapturedPoolCreation { + &self.command + } + pub fn retained_copy(&self) -> Result<Self, OperationError> { + Self::new( + self.binding.clone(), + self.minimum, + CapturedPoolCreation::parse(self.command.protected_wire()) + .map_err(|_| OperationError::RecoveryRequired)?, + ) + } +} +impl core::fmt::Debug for CreatePoolRequest { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("CreatePoolRequest(<redacted>)") + } +} +/// A claimed acknowledged inventory checkpoint. The trusted host must retain +/// its provenance independently; this value alone establishes no authority. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct InventoryCheckpointRef { + authority: radroots_domain::AuthorityRef, + revision: radroots_domain::Sequence, + head: Option<radroots_domain::CheckpointDigest>, +} +impl InventoryCheckpointRef { + pub fn from_host_metadata( + authority: radroots_domain::AuthorityRef, + revision: radroots_domain::Sequence, + head: Option<radroots_domain::CheckpointDigest>, + ) -> Result<Self, crate::workspace::WorkspaceError> { + if (revision.get() == 0) != head.is_none() { + return Err(crate::workspace::WorkspaceError::InvalidInput); + } + Ok(Self { + authority, + revision, + head, + }) + } + pub const fn authority(self) -> radroots_domain::AuthorityRef { + self.authority + } + pub const fn revision(self) -> radroots_domain::Sequence { + self.revision + } + pub const fn head(self) -> Option<radroots_domain::CheckpointDigest> { + self.head + } +} +/// Confirmed owner-private effect, without any signature or publication claim. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct PoolCreationReceipt { + attempt: CommitAttempt, + pool: PoolSnapshot, + checkpoint: InventoryCheckpointRef, +} +impl PoolCreationReceipt { + /// Reconstructs only metadata. A host must confirm its actual transaction. + pub fn from_committed_store( + attempt: CommitAttempt, + pool: PoolSnapshot, + checkpoint: InventoryCheckpointRef, + ) -> Result<Self, OperationError> { + if attempt.transaction_id().is_none() + || pool.version().get() != 1 + || checkpoint.revision().get() == 0 + { + return Err(OperationError::RecoveryRequired); + } + Ok(Self { + attempt, + pool, + checkpoint, + }) + } + /// Checkpoint retained by the trusted host for subsequent recovery admission. + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } + pub const fn attempt(&self) -> CommitAttempt { + self.attempt + } + pub const fn pool(&self) -> PoolSnapshot { + self.pool + } + pub const fn transaction_id(&self) -> Option<TransactionId> { + self.attempt.transaction_id() + } +} +/// Unknown completion retains the original operation/digest/transaction anchor. +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum PoolCreationOutcome { + Committed(Box<PoolCreationReceipt>), + Unknown(CommitAttempt), +} +/// Native and browser hosts enforce these same atomic rules, never a memory +/// success placeholder. No signing or network work occurs in these methods. +pub trait InventoryStore: WorkspaceStore { + fn create_pool( + &self, + request: CreatePoolRequest, + proof: AttachmentProof, + ) -> BoxFuture<'_, Result<PoolCreationOutcome, OperationError>>; + fn pool_creation( + &self, + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: Option<CommandDigest>, + proof: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<PoolCreationReceipt>, OperationError>>; + fn pool( + &self, + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + id: PoolId, + proof: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<radroots_domain::stock::PoolView>, OperationError>>; +} diff --git a/crates/storage/src/lib.rs b/crates/storage/src/lib.rs @@ -14,6 +14,8 @@ pub mod backup; pub mod command; mod error; pub mod event; +#[cfg(feature = "protected_outbox")] +pub mod inventory; pub mod journal; #[cfg(feature = "memory")] pub mod memory; diff --git a/crates/storage_sqlite/README.md b/crates/storage_sqlite/README.md @@ -337,3 +337,39 @@ revocation generation. An uncertain commit fences further access on that worker until close and explicit reopen. This enrollment boundary provides no pool allocation, old-order recovery, transfer, signing or business confirmation; ordinary outbox journal jobs are refused on the stock namespace. + +## Owner-private pool creation + +The current stock factory creates exact catalog version2 and protected authority +payload version2. Retained enrollment-only version1 still authenticates and +revokes with its original codec; its inventory ports refuse unsupported work. +No namespace is automatically migrated. Ordinary outbox catalogs are separate. + +`InventoryStore` admits `CreatePoolRequest` with the exact captured command, +current stock-owner binding, credential and independently retained minimum +inventory checkpoint. The backend verifies that minimum against its protected +root and authenticated retained history before reads, replay or new writes. +Protected operation links must connect that minimum to the current root; SQL +index fields alone cannot establish ancestry. A constant-memory fingerprint +rechecks the exact validated rows inside the transaction after provider IO. +The trusted host +must preserve acknowledged checkpoints through protected custody; metadata +construction alone does not establish checkpoint provenance. Bootstrap and +transfer qualification remain separate requirements. + +`stock.create_pool` captures an explicit `tick_scale` canonical integer string +from0 through6 alongside its unit and exact `initial_quantity`. Each counts +require scale0. The command digest includes precision and every semantic context +field; correlation remains diagnostic. No implicit conversion or rounding occurs. +A confirmed owner-private receipt identifies the original transaction, initial +pool effect and acknowledged checkpoint. Its pool snapshot describes that +original effect; use the current pool query for a later projection. + +One `BEGIN IMMEDIATE` transaction CAS-checks protected authority and grant, +current clock, minimum checkpoint, idempotency and pool identity, then writes +protected pool/operation/movement records and advances the protected root. +No signer or network work occurs. An empty pool has zero stock and no physical +movement. Replay returns the original effect before fresh deadline checks. +Known failures confirm rollback; unknown completion fences the owner until +reopen and reconciliation by its original operation and digest. Firm holds, +allocation, correction/deficit policy, commerce and transfer are still pending. diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs @@ -143,6 +143,60 @@ impl WorkspaceCrypto { ) .await } + pub(super) async fn seal_stock_root( + &self, + input: &super::AttachmentInput, + version: i64, + clear: &[u8], + ) -> Result<Vec<u8>, WorkspaceError> { + self.seal_bound( + stock_root_context(input, version)?, + PRIVATE_PAYLOAD_MAX_BYTES, + clear, + ) + .await + } + pub(super) async fn open_stock_root( + &self, + input: &super::AttachmentInput, + version: i64, + protected: &[u8], + ) -> Result<SecretMaterial, WorkspaceError> { + self.open_bound( + stock_root_context(input, version)?, + PRIVATE_PAYLOAD_MAX_BYTES, + protected, + ) + .await + } + pub(super) async fn seal_stock_record( + &self, + input: &super::AttachmentInput, + kind: &str, + id: &[u8; 32], + clear: &[u8], + ) -> Result<Vec<u8>, WorkspaceError> { + self.seal_bound( + stock_record_context(input, kind, id)?, + PRIVATE_PAYLOAD_MAX_BYTES, + clear, + ) + .await + } + pub(super) async fn open_stock_record( + &self, + input: &super::AttachmentInput, + kind: &str, + id: &[u8; 32], + protected: &[u8], + ) -> Result<SecretMaterial, WorkspaceError> { + self.open_bound( + stock_record_context(input, kind, id)?, + PRIVATE_PAYLOAD_MAX_BYTES, + protected, + ) + .await + } pub(super) async fn seal_stock( &self, input: &super::AttachmentInput, @@ -620,3 +674,55 @@ fn stock_context( PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?, )) } + +fn stock_root_context( + input: &super::AttachmentInput, + version: i64, +) -> Result<EnvelopeContext, WorkspaceError> { + let schema = match version { + 1 => "radroots.seller_stock.authority.v1", + 2 => "radroots.seller_stock.authority.v2", + _ => return Err(WorkspaceError::RecoveryRequired), + }; + let original = stock_context(input, true)?; + Ok(EnvelopeContext::new( + original.purpose().clone(), + original.subject().clone(), + PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?, + )) +} +fn stock_record_context( + input: &super::AttachmentInput, + kind: &str, + id: &[u8; 32], +) -> Result<EnvelopeContext, WorkspaceError> { + use sha2::{Digest, Sha256}; + let (purpose, schema) = match kind { + "pool" => ( + "radroots.seller_stock.pool", + "radroots.seller_stock.pool.v1", + ), + "operation" => ( + "radroots.seller_stock.operation", + "radroots.seller_stock.operation.v1", + ), + "movement" => ( + "radroots.seller_stock.movement", + "radroots.seller_stock.movement.v1", + ), + _ => return Err(WorkspaceError::InvalidInput), + }; + let mut h = Sha256::new(); + h.update(b"radroots.seller_stock.record_context.v1\0"); + h.update(input.workspace_id().as_bytes()); + h.update(input.authority().executor_id().as_bytes()); + h.update(input.authority().generation().get().to_be_bytes()); + h.update(id); + let id = radroots_domain::CommandDigest::from_bytes(h.finalize().into()); + Ok(EnvelopeContext::new( + EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?, + EnvelopeSubject::parse("stock_record", id.to_string()) + .map_err(|_| WorkspaceError::InvalidInput)?, + PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?, + )) +} diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs @@ -65,6 +65,7 @@ pub struct StockAuthorityReceipt { pub(super) input: AttachmentInput, pub(super) transaction: TransactionId, pub(super) revocation: Sequence, + pub(super) inventory: Option<radroots_storage::inventory::InventoryCheckpointRef>, } impl StockAuthorityReceipt { pub fn input(&self) -> &AttachmentInput { @@ -73,6 +74,12 @@ impl StockAuthorityReceipt { pub const fn transaction_id(&self) -> TransactionId { self.transaction } + /// Current protected inventory checkpoint, absent for enrollment-only catalogs. + pub const fn inventory_checkpoint( + &self, + ) -> Option<radroots_storage::inventory::InventoryCheckpointRef> { + self.inventory + } pub const fn revocation_generation(&self) -> Sequence { self.revocation } @@ -130,13 +137,100 @@ impl NativeWorkspace { self.worker.stock_authority(input, proof).await } } +struct Authority { + input: AttachmentInput, + transaction: TransactionId, + revocation: Sequence, + inventory: Option<InventoryCheckpoint>, +} +#[derive(Clone, Copy, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct InventoryCheckpoint { + revision: Sequence, + pools: Sequence, + movements: Sequence, + #[serde(deserialize_with = "required_nullable")] + head: Option<radroots_domain::CheckpointDigest>, +} +fn required_nullable<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( + d: D, +) -> Result<Option<T>, D::Error> { + Option::deserialize(d) +} #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] -struct Authority { +struct AuthorityV1 { + version: u8, + input: AttachmentInput, + transaction: TransactionId, + revocation: Sequence, +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct AuthorityV2 { version: u8, input: AttachmentInput, transaction: TransactionId, revocation: Sequence, + inventory: InventoryCheckpoint, +} +impl Authority { + fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> { + let bytes = match self.inventory { + None => serde_json::to_vec(&AuthorityV1 { + version: 1, + input: self.input.clone(), + transaction: self.transaction, + revocation: self.revocation, + }), + Some(inventory) => serde_json::to_vec(&AuthorityV2 { + version: 2, + input: self.input.clone(), + transaction: self.transaction, + revocation: self.revocation, + inventory, + }), + } + .map_err(|_| WorkspaceError::StorageFailure)?; + Ok(zeroize::Zeroizing::new(bytes)) + } + fn decode(bytes: &[u8], catalog: i64) -> Result<Self, WorkspaceError> { + let value = match catalog { + 1 => { + let v: AuthorityV1 = closed_record(bytes)?; + if v.version != 1 { + return Err(WorkspaceError::RecoveryRequired); + } + Self { + input: v.input, + transaction: v.transaction, + revocation: v.revocation, + inventory: None, + } + } + 2 => { + let v: AuthorityV2 = closed_record(bytes)?; + if v.version != 2 || (v.inventory.revision.get() == 0) != v.inventory.head.is_none() + { + return Err(WorkspaceError::RecoveryRequired); + } + Self { + input: v.input, + transaction: v.transaction, + revocation: v.revocation, + inventory: Some(v.inventory), + } + } + _ => return Err(WorkspaceError::RecoveryRequired), + }; + if value.revocation.get() == 0 { + return Err(WorkspaceError::RecoveryRequired); + } + Ok(value) + } + fn version(&self) -> i64 { + if self.inventory.is_some() { 2 } else { 1 } + } } pub(super) struct Initial { pub grant: GrantRecord, @@ -144,27 +238,8 @@ pub(super) struct Initial { pub expires_at: radroots_domain::UnixSeconds, pub clock: Arc<dyn WorkspaceClock>, } -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 CATALOG: [&str; 2] = [AUTHORITY, GRANTS]; -async fn catalog(connection: &mut SqliteConnection) -> Result<(), WorkspaceError> { - let valid: i64 = sqlx::query_scalar("SELECT CASE WHEN count(*)=2 AND sum(CASE WHEN type='table' AND name='stock_authority' AND tbl_name='stock_authority' AND sql=? THEN 1 WHEN type='table' AND name='stock_grants' AND tbl_name='stock_grants' AND sql=? THEN 1 ELSE 0 END)=2 THEN 1 ELSE 0 END FROM sqlite_schema").bind(AUTHORITY).bind(GRANTS).fetch_one(&mut *connection).await.map_err(|_| WorkspaceError::RecoveryRequired)?; - let version: i64 = sqlx::query_scalar("PRAGMA user_version") - .fetch_one(&mut *connection) - .await - .map_err(|_| WorkspaceError::RecoveryRequired)?; - if valid != 1 || version != 1 { - return Err(WorkspaceError::RecoveryRequired); - } - let integrity: String = sqlx::query_scalar("PRAGMA quick_check(1)") - .fetch_one(connection) - .await - .map_err(|_| WorkspaceError::RecoveryRequired)?; - if integrity != "ok" { - return Err(WorkspaceError::RecoveryRequired); - } - Ok(()) -} +pub(super) mod inventory; +mod schema; pub(super) async fn initialize( connection: &mut SqliteConnection, namespace: &Namespace, @@ -175,15 +250,20 @@ pub(super) async fn initialize( namespace.validate()?; if let Some(initial) = initial { let authority = Authority { - version: 1, input: input.clone(), transaction: initial.transaction, revocation: Sequence::new(1).map_err(|_| WorkspaceError::InvalidInput)?, + inventory: Some(InventoryCheckpoint { + revision: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, + head: None, + pools: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, + movements: Sequence::new(0).map_err(|_| WorkspaceError::InvalidInput)?, + }), }; - let clear = zeroize::Zeroizing::new( - serde_json::to_vec(&authority).map_err(|_| WorkspaceError::StorageFailure)?, - ); - let root = crypto.seal_stock(input, true, &clear).await?; + 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?; @@ -207,13 +287,13 @@ pub(super) async fn initialize( if now >= initial.expires_at { return Err(WorkspaceError::GrantExpired); } - for sql in CATALOG { + for (_, _, _, sql) in schema::objects(schema::CURRENT)? { sqlx::raw_sql(sql) .execute(&mut *tx) .await .map_err(|_| WorkspaceError::StorageFailure)?; } - sqlx::query("PRAGMA user_version=1") + sqlx::query("PRAGMA user_version=2") .execute(&mut *tx) .await .map_err(|_| WorkspaceError::StorageFailure)?; @@ -241,7 +321,8 @@ pub(super) async fn initialize( .await .map_err(|_| WorkspaceError::CommitUnknown)?; } - catalog(connection).await?; + schema::admit(connection).await?; + schema::integrity(connection).await?; read(connection, input, crypto).await?; namespace.validate() } @@ -253,11 +334,13 @@ async fn read( // 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)?; - let clear = crypto.open_stock(input, true, &root).await?; - let authority: Authority = clear - .expose_secret(|bytes| serde_json::from_slice(bytes)) + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *connection) + .await .map_err(|_| WorkspaceError::RecoveryRequired)?; - if authority.version != 1 || authority.input != *input || authority.revocation.get() == 0 { + 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 { return Err(WorkspaceError::WrongNamespace); } let clear = crypto.open_stock(input, false, &grant).await?; @@ -266,6 +349,9 @@ async fn read( if record.scope() != WorkspaceScope::SellerStockOwner { return Err(WorkspaceError::RecoveryRequired); } + if let Some(checkpoint) = authority.inventory { + inventory::check_head(connection, checkpoint).await?; + } Ok((authority, record, root, grant)) } pub(super) async fn authenticate( @@ -303,6 +389,16 @@ pub(super) async fn authenticate( input: authority.input, transaction: authority.transaction, revocation: authority.revocation, + inventory: authority + .inventory + .map(|v| { + radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( + expected.authority(), + v.revision, + v.head, + ) + }) + .transpose()?, }, binding, )) @@ -331,10 +427,10 @@ pub(super) async fn revoke( .ok_or(WorkspaceError::Capacity)?, ) .map_err(|_| WorkspaceError::Capacity)?; - let clear = zeroize::Zeroizing::new( - serde_json::to_vec(&authority).map_err(|_| WorkspaceError::StorageFailure)?, - ); - let root = crypto.seal_stock(expected, true, &clear).await?; + let clear = authority.encode()?; + let root = crypto + .seal_stock_root(expected, authority.version(), &clear) + .await?; let grant = crypto .seal_stock(expected, false, &record.encode()?) .await?; @@ -396,3 +492,62 @@ async fn unchanged( } Ok(()) } + +impl radroots_storage::inventory::InventoryStore for NativeWorkspace { + fn create_pool( + &self, + request: radroots_storage::inventory::CreatePoolRequest, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result< + radroots_storage::inventory::PoolCreationOutcome, + radroots_storage::command::OperationError, + >, + > { + Box::pin(self.worker.create_pool(request, proof)) + } + fn pool_creation( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + operation: radroots_domain::OperationId, + digest: Option<radroots_domain::CommandDigest>, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result< + Option<radroots_storage::inventory::PoolCreationReceipt>, + radroots_storage::command::OperationError, + >, + > { + Box::pin( + self.worker + .pool_creation(binding, minimum, operation, digest, proof), + ) + } + fn pool( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + id: radroots_domain::PoolId, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result<Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>, + > { + Box::pin(self.worker.pool(binding, minimum, id, proof)) + } +} + +#[cfg(test)] +mod tests; + +fn closed_record<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> Result<T, WorkspaceError> { + if bytes.len() > 16 * 1024 + || bytes.iter().copied().find(|b| !b.is_ascii_whitespace()) != Some(b'{') + { + return Err(WorkspaceError::RecoveryRequired); + } + serde_json::from_slice(bytes).map_err(|_| WorkspaceError::RecoveryRequired) +} diff --git a/crates/storage_sqlite/src/workspace/stock/inventory.rs b/crates/storage_sqlite/src/workspace/stock/inventory.rs @@ -0,0 +1,877 @@ +//! Owner-private pool creation on the existing connection owner. +use super::*; +use radroots_domain::{ + CheckpointDigest, CommandDigest, OperationId, PoolId, UnixSeconds, + stock::{PhysicalBalances, PoolBalances, PoolSnapshot}, +}; +use radroots_storage::{ + command::{CommitAttempt, OperationError, protected::same_binding}, + inventory::{CreatePoolRequest, PoolCreationOutcome, PoolCreationReceipt}, +}; +use serde_json::value::RawValue; +use sha2::{Digest, Sha256}; +use sqlx::Row; + +pub(super) async fn check_head( + connection: &mut SqliteConnection, + checkpoint: InventoryCheckpoint, +) -> Result<(), WorkspaceError> { + let row=sqlx::query("SELECT count(*),coalesce(max(revision),0),coalesce(sum(CASE WHEN revision=? AND chain_head=? THEN 1 ELSE 0 END),0) FROM stock_operations") + .bind(checkpoint.revision.get() as i64).bind(checkpoint.head.map(|id|id.as_bytes().to_vec())).fetch_one(&mut *connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?; + let count: i64 = row + .try_get(0) + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let max: i64 = row + .try_get(1) + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let matched: i64 = row + .try_get(2) + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let pools: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_pools") + .fetch_one(&mut *connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let movements: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_movements") + .fetch_one(&mut *connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + if pools != checkpoint.pools.get() as i64 || movements != checkpoint.movements.get() as i64 { + return Err(WorkspaceError::RecoveryRequired); + } + if count != checkpoint.revision.get() as i64 + || max != count + || matched != i64::from(checkpoint.head.is_some()) + { + return Err(WorkspaceError::RecoveryRequired); + } + Ok(()) +} +struct Access { + authority: Authority, + record: GrantRecord, + root: Vec<u8>, + grant: Vec<u8>, + current: WorkspaceBinding, + minimum_proof: MinimumProof, +} +pub(in crate::workspace) struct Turn<'a> { + pub connection: &'a mut SqliteConnection, + pub namespace: &'a Namespace, + pub selected: &'a AttachmentInput, + pub crypto: &'a WorkspaceCrypto, + pub clock: &'a dyn WorkspaceClock, + pub uncertain: &'a mut bool, +} +impl Turn<'_> { + async fn access( + &mut self, + binding: &WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + proof: &AttachmentProof, + ) -> Result<Access, OperationError> { + if *self.uncertain { + return Err(OperationError::RecoveryRequired); + } + self.namespace.validate()?; + let (authority, record, root, grant) = + super::read(self.connection, self.selected, 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.inventory.is_none() { + return Err(OperationError::UnsupportedOperation); + } + + let minimum_proof = authenticate_minimum( + self.connection, + self.selected, + self.crypto, + &current, + authority + .inventory + .ok_or(OperationError::UnsupportedOperation)?, + minimum, + ) + .await?; + self.namespace.validate()?; + Ok(Access { + authority, + record, + root, + grant, + current, + minimum_proof, + }) + } + pub async fn create( + &mut self, + request: CreatePoolRequest, + proof: AttachmentProof, + ) -> Result<PoolCreationOutcome, OperationError> { + let mut access = self + .access(request.binding(), request.minimum_checkpoint(), &proof) + .await?; + let context = request.command().context(); + let operation = context.operation_id(); + let digest = request.command().digest(); + // Retained identity precedes every fresh deadline or pool-existence check. + if let Some(retained) = read_operation( + self.connection, + self.selected, + self.crypto, + request.binding(), + operation, + ) + .await? + { + if retained.digest != digest { + return Err(OperationError::IdempotencyConflict); + } + self.confirm(&access, &proof, Some(&retained), None, None, None) + .await?; + return Ok(PoolCreationOutcome::Committed(Box::new(retained.receipt))); + } + if access.current.observed_at() < request.binding().observed_at() { + return Err(WorkspaceError::Unavailable.into()); + } + if access.current.observed_at() >= context.not_after() { + return Err(OperationError::DeadlineExceeded); + } + let input = request.command().input(); + if read_pool(self.connection, self.selected, self.crypto, input.id()) + .await? + .is_some() + { + return Err(OperationError::StaleState); + } + let zero = + radroots_domain::Sequence::new(1).map_err(|_| OperationError::RecoveryRequired)?; + let pool = PoolSnapshot::new( + input.id(), + input.unit(), + PoolBalances::new( + input.initial_ticks(), + PhysicalBalances { + available: input.initial_ticks(), + ..PhysicalBalances::ZERO + }, + ) + .map_err(|_| OperationError::InvalidCommand)?, + zero, + ); + let transaction = TransactionId::from_bytes(super::super::random()?); + let movement = if input.initial_ticks() == radroots_domain::stock::StockTicks::ZERO { + None + } else { + Some(super::super::random()?) + }; + let checkpoint = access + .authority + .inventory + .ok_or(OperationError::UnsupportedOperation)?; + let revision = Sequence::new( + checkpoint + .revision + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?; + let head = chain_head(ChainInput { + previous: checkpoint.head, + revision, + binding: request.binding(), + operation, + digest, + transaction, + pool, + movement, + })?; + let attempt = CommitAttempt::new( + self.selected.workspace_id(), + operation, + digest, + Some(transaction), + ); + let receipt = PoolCreationReceipt::from_committed_store( + attempt, + pool, + radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( + self.selected.authority(), + revision, + Some(head), + )?, + )?; + let protected_pool = self + .crypto + .seal_stock_record( + self.selected, + "pool", + pool.id().as_bytes(), + &encode(&PoolWire { + version: 1, + label: input.label(), + pool, + })?, + ) + .await?; + let protected_movement = if let Some(id) = movement { + Some( + self.crypto + .seal_stock_record( + self.selected, + "movement", + &id, + &encode(&Movement { + version: 1, + operation, + digest, + pool: pool.id(), + quantity: input.initial_ticks(), + kind: MovementKind::Introduced, + })?, + ) + .await?, + ) + } else { + None + }; + let command: &RawValue = serde_json::from_slice(request.command().protected_wire()) + .map_err(|_| OperationError::InvalidCommand)?; + let protected_operation = self + .crypto + .seal_stock_record( + self.selected, + "operation", + operation.as_bytes(), + &encode(&OperationWire { + version: 1, + 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, + })?, + ) + .await?; + access.authority.inventory = Some(InventoryCheckpoint { + revision, + head: Some(head), + pools: Sequence::new( + checkpoint + .pools + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?, + movements: Sequence::new( + checkpoint + .movements + .get() + .checked_add(u64::from(movement.is_some())) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?, + }); + let root = self + .crypto + .seal_stock_root(self.selected, 2, &access.authority.encode()?) + .await?; + self.namespace.validate()?; + let mut tx = self + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let changed:Result<(),OperationError>=async { + super::unchanged(&mut tx,self.selected,&access.root,&access.grant).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()?)?; + same_binding(request.binding(),&current)?; + 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)?; + if absent!=0 {return Err(OperationError::StaleState);} + let existing:i64=sqlx::query_scalar("SELECT count(*) FROM stock_pools WHERE pool_id=?").bind(pool.id().as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?; + if existing!=0 {return Err(OperationError::StaleState);} + sqlx::query("INSERT INTO stock_pools(pool_id,revision,protected) VALUES(?,1,?)").bind(pool.id().as_bytes().as_slice()).bind(protected_pool).execute(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?; + sqlx::query("INSERT INTO stock_operations(actor,grant_id,operation_id,command_digest,transaction_id,pool_id,revision,chain_head,protected) VALUES(?,?,?,?,?,?,?,?,?)") + .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()).bind(digest.as_bytes().as_slice()).bind(transaction.as_bytes().as_slice()).bind(pool.id().as_bytes().as_slice()).bind(revision.get() as i64).bind(head.as_bytes().as_slice()).bind(protected_operation).execute(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?; + if let (Some(id),Some(protected))=(movement,protected_movement) { + sqlx::query("INSERT INTO stock_movements(movement_id,actor,grant_id,operation_id,pool_id,protected) VALUES(?,?,?,?,?,?)").bind(id.as_slice()).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()).bind(pool.id().as_bytes().as_slice()).bind(protected).execute(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?; + } + let changed=sqlx::query("UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?").bind(root).bind(&access.root).execute(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?; + if changed.rows_affected()!=1 {return Err(OperationError::RecoveryRequired);}self.namespace.validate()?;Ok(()) + }.await; + if let Err(error) = changed { + if tx.rollback().await.is_err() { + *self.uncertain = true; + return Ok(PoolCreationOutcome::Unknown(attempt)); + } + return Err(error); + } + if tx.commit().await.is_err() { + *self.uncertain = true; + return Ok(PoolCreationOutcome::Unknown(attempt)); + } + Ok(PoolCreationOutcome::Committed(Box::new(receipt))) + } + async fn confirm( + &mut self, + access: &Access, + proof: &AttachmentProof, + operation: Option<&Retained>, + pool: Option<&RetainedPool>, + absent_operation: Option<OperationId>, + absent_pool: Option<PoolId>, + ) -> Result<(), OperationError> { + let mut tx = self + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked:Result<(),OperationError>=async { + self.namespace.validate()?; + super::unchanged(&mut tx,self.selected,&access.root,&access.grant).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(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)?; + 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)?; + 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)?; + if count!=1 {return Err(OperationError::RecoveryRequired);} + } + + } + if let Some(pool)=pool {let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_pools WHERE pool_id=? AND revision=? AND protected=?").bind(pool.pool.id().as_bytes().as_slice()).bind(pool.pool.version().get() as i64).bind(&pool.protected).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;if count!=1 {return Err(OperationError::RecoveryRequired);}} + Ok(()) + }.await; + if tx.rollback().await.is_err() { + *self.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + checked + } + pub async fn creation( + &mut self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + operation: OperationId, + digest: Option<CommandDigest>, + proof: AttachmentProof, + ) -> Result<Option<PoolCreationReceipt>, OperationError> { + let access = self.access(&binding, minimum, &proof).await?; + let result = read_operation( + self.connection, + self.selected, + self.crypto, + &binding, + operation, + ) + .await?; + if let Some(retained) = &result + && digest.is_some_and(|d| d != retained.digest) + { + return Err(OperationError::IdempotencyConflict); + } + self.confirm( + &access, + &proof, + result.as_ref(), + None, + result.is_none().then_some(operation), + None, + ) + .await?; + Ok(result.map(|v| v.receipt)) + } + pub async fn pool( + &mut self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + id: PoolId, + proof: AttachmentProof, + ) -> Result<Option<radroots_domain::stock::PoolView>, OperationError> { + let access = self.access(&binding, minimum, &proof).await?; + let result = read_pool(self.connection, self.selected, self.crypto, id).await?; + self.confirm( + &access, + &proof, + None, + result.as_ref(), + None, + result.is_none().then_some(id), + ) + .await?; + Ok(result.map(|v| v.view)) + } +} +struct RetainedPool { + view: radroots_domain::stock::PoolView, + pool: PoolSnapshot, + protected: Vec<u8>, +} +#[derive(Serialize)] +struct PoolWire<'a> { + version: u8, + label: &'a str, + pool: PoolSnapshot, +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct PoolDecode { + version: u8, + label: String, + pool: PoolSnapshot, +} +async fn read_pool( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + id: PoolId, +) -> Result<Option<RetainedPool>, OperationError> { + let row=sqlx::query("SELECT revision,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_pools WHERE pool_id=?").bind(id.as_bytes().as_slice()).fetch_optional(connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let Some(row) = row else { return Ok(None) }; + let revision: i64 = row + .try_get(0) + .map_err(|_| OperationError::RecoveryRequired)?; + let protected: Vec<u8> = row + .try_get::<Option<Vec<u8>>, _>(1) + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + let clear = crypto + .open_stock_record(input, "pool", id.as_bytes(), &protected) + .await?; + let decoded: PoolDecode = clear + .expose_secret(|bytes| super::closed_record(bytes)) + .map_err(|_| OperationError::RecoveryRequired)?; + if decoded.version != 1 + || decoded.label.len() > 160 + || decoded.label.chars().any(char::is_control) + || decoded.pool.id() != id + || revision <= 0 + || decoded.pool.version().get() != revision as u64 + { + return Err(OperationError::RecoveryRequired); + } + let view = radroots_domain::stock::PoolView::new(&decoded.label, decoded.pool) + .map_err(|_| OperationError::RecoveryRequired)?; + Ok(Some(RetainedPool { + view, + pool: decoded.pool, + protected, + })) +} +#[derive(Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +enum MovementKind { + Introduced, +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Movement { + version: u8, + operation: OperationId, + digest: CommandDigest, + pool: PoolId, + quantity: radroots_domain::stock::StockTicks, + kind: MovementKind, +} +#[derive(Serialize)] +struct OperationWire<'a> { + version: u8, + selection: &'a AttachmentInput, + scope: WorkspaceScope, + principal: &'a str, + grant_revision: Sequence, + grant_expires_at: UnixSeconds, + observed_at: UnixSeconds, + minimum_revision: Sequence, + minimum_head: Option<CheckpointDigest>, + transaction: TransactionId, + revision: Sequence, + previous_head: Option<CheckpointDigest>, + head: CheckpointDigest, + command: &'a RawValue, + pool: PoolSnapshot, + movement: Option<[u8; 32]>, +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct OperationDecode<'a> { + version: u8, + selection: AttachmentInput, + scope: WorkspaceScope, + principal: String, + grant_revision: Sequence, + grant_expires_at: UnixSeconds, + observed_at: UnixSeconds, + minimum_revision: Sequence, + #[serde(deserialize_with = "super::required_nullable")] + minimum_head: Option<CheckpointDigest>, + transaction: TransactionId, + revision: Sequence, + #[serde(deserialize_with = "super::required_nullable")] + previous_head: Option<CheckpointDigest>, + head: CheckpointDigest, + #[serde(borrow)] + command: &'a RawValue, + pool: PoolSnapshot, + #[serde(deserialize_with = "super::required_nullable")] + movement: Option<[u8; 32]>, +} +struct OperationData { + version: u8, + transaction: TransactionId, + revision: Sequence, + previous_head: Option<CheckpointDigest>, + head: CheckpointDigest, + pool: PoolSnapshot, + movement: Option<[u8; 32]>, +} +struct Retained { + previous_head: Option<CheckpointDigest>, + movement: Option<[u8; 32]>, + movement_protected: Option<Vec<u8>>, + receipt: PoolCreationReceipt, + digest: CommandDigest, + protected: Vec<u8>, +} +async fn read_operation( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + 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 Some(row) = row else { return Ok(None) }; + let protected: Vec<u8> = row + .try_get::<Option<Vec<u8>>, _>(5) + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + let clear = crypto + .open_stock_record(input, "operation", operation.as_bytes(), &protected) + .await?; + let (request, decoded) = clear.expose_secret(|bytes| -> Result<_, OperationError> { + let decoded: OperationDecode<'_> = + super::closed_record(bytes).map_err(|_| OperationError::RecoveryRequired)?; + let captured = WorkspaceBinding::from_authenticated_host( + decoded.selection, + decoded.scope, + binding.actor(), + decoded.principal, + decoded.grant_revision, + decoded.grant_expires_at, + decoded.observed_at, + )?; + let minimum = radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( + captured.input().authority(), + decoded.minimum_revision, + decoded.minimum_head, + )?; + let request = CreatePoolRequest::from_protected_wire( + captured, + minimum, + decoded.command.get().as_bytes(), + )?; + Ok(( + request, + OperationData { + version: decoded.version, + transaction: decoded.transaction, + revision: decoded.revision, + previous_head: decoded.previous_head, + head: decoded.head, + pool: decoded.pool, + movement: decoded.movement, + }, + )) + })?; + same_binding(request.binding(), binding)?; + let digest = request.command().digest(); + let pool_input = request.command().input(); + let physical = decoded.pool.balances().physical(); + if decoded.version != 1 + || request.command().context().operation_id() != operation + || decoded.revision.get() == 0 + || (decoded.revision.get() == 1) != decoded.previous_head.is_none() + || decoded.pool.version().get() != 1 + || decoded.pool.id() != pool_input.id() + || decoded.pool.unit() != pool_input.unit() + || decoded.pool.balances().introduced() != pool_input.initial_ticks() + || physical.available != pool_input.initial_ticks() + || physical + != (PhysicalBalances { + available: pool_input.initial_ticks(), + ..PhysicalBalances::ZERO + }) + { + return Err(OperationError::RecoveryRequired); + } + let head = chain_head(ChainInput { + previous: decoded.previous_head, + revision: decoded.revision, + binding: request.binding(), + operation, + digest, + transaction: decoded.transaction, + pool: decoded.pool, + movement: decoded.movement, + })?; + let pool_id = decoded.pool.id(); + for (column, expected) in [ + (0, digest.as_bytes()), + (1, decoded.transaction.as_bytes()), + (2, pool_id.as_bytes()), + (4, head.as_bytes()), + ] { + let observed: Vec<u8> = row + .try_get(column) + .map_err(|_| OperationError::RecoveryRequired)?; + if observed != expected { + return Err(OperationError::RecoveryRequired); + } + } + let revision: i64 = row + .try_get(3) + .map_err(|_| OperationError::RecoveryRequired)?; + 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)?; + 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 clear = crypto + .open_stock_record(input, "movement", &id, &protected) + .await?; + let movement: Movement = clear + .expose_secret(|bytes| super::closed_record(bytes)) + .map_err(|_| OperationError::RecoveryRequired)?; + if movement.version != 1 + || movement.operation != operation + || movement.digest != digest + || movement.pool != decoded.pool.id() + || movement.quantity != pool_input.initial_ticks() + || movement.quantity == radroots_domain::stock::StockTicks::ZERO + { + return Err(OperationError::RecoveryRequired); + } + Some(protected) + } else { + if pool_input.initial_ticks() != radroots_domain::stock::StockTicks::ZERO { + return Err(OperationError::RecoveryRequired); + } + None + }; + let receipt = PoolCreationReceipt::from_committed_store( + CommitAttempt::new( + input.workspace_id(), + operation, + digest, + Some(decoded.transaction), + ), + decoded.pool, + radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( + request.command().context().authority(), + decoded.revision, + Some(decoded.head), + )?, + )?; + Ok(Some(Retained { + previous_head: decoded.previous_head, + movement: decoded.movement, + movement_protected, + receipt, + digest, + protected, + })) +} +fn encode(value: &impl Serialize) -> Result<zeroize::Zeroizing<Vec<u8>>, OperationError> { + let bytes = zeroize::Zeroizing::new( + serde_json::to_vec(value).map_err(|_| OperationError::StorageFailure)?, + ); + if bytes.len() > 16 * 1024 { + return Err(OperationError::InvalidCommand); + } + Ok(bytes) +} +struct ChainInput<'a> { + previous: Option<CheckpointDigest>, + revision: Sequence, + binding: &'a WorkspaceBinding, + operation: OperationId, + digest: CommandDigest, + transaction: TransactionId, + pool: PoolSnapshot, + movement: Option<[u8; 32]>, +} +fn chain_head(value: ChainInput<'_>) -> Result<CheckpointDigest, OperationError> { + let ChainInput { + previous, + revision, + binding, + operation, + digest, + transaction, + pool, + movement, + } = value; + let mut h = Sha256::new(); + h.update(b"radroots.seller_stock.inventory_chain.v1\0"); + h.update([u8::from(previous.is_some())]); + h.update(previous.map(|v| *v.as_bytes()).unwrap_or([0; 32])); + h.update(revision.get().to_be_bytes()); + h.update(binding.input().workspace_id().as_bytes()); + h.update(binding.actor().participant().as_bytes()); + h.update(binding.input().grant_id().as_bytes()); + h.update(operation.as_bytes()); + h.update(digest.as_bytes()); + h.update(transaction.as_bytes()); + h.update(pool.id().as_bytes()); + h.update(encode(&pool)?.as_slice()); + h.update([u8::from(movement.is_some())]); + h.update(movement.unwrap_or([0; 32])); + Ok(CheckpointDigest::from_bytes(h.finalize().into())) +} + +/// 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. +struct MinimumProof { + lower: u64, + upper: u64, + digest: [u8; 32], +} +impl MinimumProof { + async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> { + let mut hash = history_hash(); + for revision in (self.lower..=self.upper).rev() { + let row=sqlx::query("SELECT actor,grant_id,operation_id,command_digest,transaction_id,pool_id,chain_head,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_operations WHERE revision=?") + .bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + hash.update(revision.to_be_bytes()); + for column in 0..7 { + let bytes: Vec<u8> = row + .try_get(column) + .map_err(|_| OperationError::RecoveryRequired)?; + if bytes.len() != 32 { + return Err(OperationError::RecoveryRequired); + } + hash.update(bytes); + } + let protected: Vec<u8> = row + .try_get::<Option<Vec<u8>>, _>(7) + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + hash.update((protected.len() as u64).to_be_bytes()); + hash.update(protected); + } + let actual: [u8; 32] = hash.finalize().into(); + if actual != self.digest { + return Err(OperationError::RecoveryRequired); + } + Ok(()) + } +} +fn history_hash() -> Sha256 { + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.ancestry_snapshot.v1\0"); + hash +} +async fn authenticate_minimum( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + binding: &WorkspaceBinding, + current: InventoryCheckpoint, + minimum: radroots_storage::inventory::InventoryCheckpointRef, +) -> Result<MinimumProof, OperationError> { + if minimum.authority() != input.authority() { + return Err(WorkspaceError::StaleAuthority.into()); + } + if minimum.revision().get() > current.revision.get() { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + let lower = minimum.revision().get().max(1); + let upper = current.revision.get(); + let mut hash = history_hash(); + let mut expected = current.head; + for revision in (lower..=upper).rev() { + let id:Vec<u8>=sqlx::query_scalar("SELECT operation_id FROM stock_operations WHERE revision=? AND length(operation_id)=32") + .bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + let operation = OperationId::from_bytes( + id.try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let retained = read_operation(connection, input, crypto, binding, operation) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let receipt = &retained.receipt; + if receipt.checkpoint().revision().get() != revision + || receipt.checkpoint().head() != expected + { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + if revision == minimum.revision().get() && expected != minimum.head() { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + hash.update(revision.to_be_bytes()); + hash.update(binding.actor().participant().as_bytes()); + hash.update(binding.input().grant_id().as_bytes()); + hash.update(operation.as_bytes()); + hash.update(retained.digest.as_bytes()); + hash.update( + receipt + .transaction_id() + .ok_or(OperationError::RecoveryRequired)? + .as_bytes(), + ); + hash.update(receipt.pool().id().as_bytes()); + hash.update(expected.ok_or(OperationError::RecoveryRequired)?.as_bytes()); + hash.update((retained.protected.len() as u64).to_be_bytes()); + hash.update(&retained.protected); + expected = retained.previous_head; + } + if minimum.revision().get() == 0 && expected.is_some() { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + Ok(MinimumProof { + lower, + upper, + digest: hash.finalize().into(), + }) +} diff --git a/crates/storage_sqlite/src/workspace/stock/schema.rs b/crates/storage_sqlite/src/workspace/stock/schema.rs @@ -0,0 +1,86 @@ +//! Exact stock catalogs. Enrollment-only version1 is retained without upgrade. +use super::WorkspaceError; +use sqlx::SqliteConnection; +pub(super) const CURRENT: i64 = 2; +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"; +const OPERATIONS: &str = "CREATE TABLE stock_operations (actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL REFERENCES stock_grants(grant_id), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), command_digest BLOB NOT NULL CHECK(length(command_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), pool_id BLOB NOT NULL REFERENCES stock_pools(pool_id) DEFERRABLE INITIALLY DEFERRED, revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(actor,grant_id,operation_id)) STRICT, WITHOUT ROWID"; +const TX: &str = + "CREATE UNIQUE INDEX stock_operation_transaction_identity ON stock_operations(transaction_id)"; +const REVISION: &str = + "CREATE UNIQUE INDEX stock_operation_revision_identity ON stock_operations(revision)"; +const HEAD: &str = + "CREATE UNIQUE INDEX stock_operation_head_identity ON stock_operations(chain_head)"; +const MOVEMENTS: &str = "CREATE TABLE stock_movements (movement_id BLOB PRIMARY KEY CHECK(length(movement_id)=32), actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL CHECK(length(grant_id)=32), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), pool_id BLOB NOT NULL REFERENCES stock_pools(pool_id), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), FOREIGN KEY(actor,grant_id,operation_id) REFERENCES stock_operations(actor,grant_id,operation_id)) STRICT, WITHOUT ROWID"; +pub(super) fn objects( + version: i64, +) -> Result<Vec<(&'static str, &'static str, &'static str, &'static str)>, WorkspaceError> { + let mut objects = vec![ + ("table", "stock_authority", "stock_authority", AUTHORITY), + ("table", "stock_grants", "stock_grants", GRANTS), + ]; + match version { + 1 => {} + 2 => objects.extend([ + ("table", "stock_pools", "stock_pools", POOLS), + ("table", "stock_operations", "stock_operations", OPERATIONS), + ( + "index", + "stock_operation_transaction_identity", + "stock_operations", + TX, + ), + ( + "index", + "stock_operation_revision_identity", + "stock_operations", + REVISION, + ), + ( + "index", + "stock_operation_head_identity", + "stock_operations", + HEAD, + ), + ("table", "stock_movements", "stock_movements", MOVEMENTS), + ]), + _ => return Err(WorkspaceError::RecoveryRequired), + } + Ok(objects) +} +pub(super) async fn admit(connection: &mut SqliteConnection) -> Result<i64, WorkspaceError> { + let version: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + let objects = objects(version)?; + let mut sql = String::from("SELECT CASE WHEN count(*)=? AND sum(CASE"); + for _ in &objects { + sql.push_str(" WHEN type=? AND name=? AND tbl_name=? AND sql=? THEN 1"); + } + sql.push_str(" ELSE 0 END)=? THEN 1 ELSE 0 END FROM sqlite_schema"); + let mut query = sqlx::query_scalar(sqlx::AssertSqlSafe(sql)).bind(objects.len() as i64); + for (kind, name, owner, definition) in &objects { + query = query.bind(*kind).bind(*name).bind(*owner).bind(*definition); + } + let valid: i64 = query + .bind(objects.len() as i64) + .fetch_one(connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + if valid != 1 { + return Err(WorkspaceError::RecoveryRequired); + } + Ok(version) +} +pub(super) async fn integrity(connection: &mut SqliteConnection) -> Result<(), WorkspaceError> { + let check: String = sqlx::query_scalar("PRAGMA quick_check(1)") + .fetch_one(connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; + if check != "ok" { + return Err(WorkspaceError::RecoveryRequired); + } + Ok(()) +} diff --git a/crates/storage_sqlite/src/workspace/stock/tests.rs b/crates/storage_sqlite/src/workspace/stock/tests.rs @@ -0,0 +1,130 @@ +use super::*; +use crate::workspace::{ + fs::Kind, + tests::{CryptoFixture, participant}, +}; +use radroots_domain::{CommandContextData, OperationId, PoolId, UnixSeconds}; +use radroots_storage::{ + command::OperationError, + inventory::{CreatePoolRequest, InventoryCheckpointRef, InventoryStore}, +}; +struct Clock; +impl WorkspaceClock for Clock { + fn now(&self) -> Result<UnixSeconds, WorkspaceError> { + Ok(UnixSeconds::new(100).unwrap()) + } +} +#[tokio::test] +async fn retained_enrollment_v1_authenticates_but_never_auto_creates_inventory() { + let fixture = CryptoFixture::new(); + let path = fixture.root().join("retained-v1"); + let (input, proof, record) = SellerStockConfig::new( + participant(), + participant(), + "retained-stock-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(&[0xA3; 32]).unwrap(), + ) + .unwrap(); + // Exact version1 shape introduced by a4cc1a1c; this is a literal retained + // codec/catalog fixture, not a claim that a predecessor binary ran here. + let clear=zeroize::Zeroizing::new(serde_json::to_vec(&serde_json::json!({"version":1,"input":input,"transaction":TransactionId::from_bytes([9;32]),"revocation":"1"})).unwrap()); + let crypto = fixture.crypto(); + let root = crypto.seal_stock(&input, true, &clear).await.unwrap(); + let grant = crypto + .seal_stock(&input, false, &record.encode().unwrap()) + .await + .unwrap(); + let namespace = Namespace::acquire_kind(&path, true, Kind::SellerStock).unwrap(); + let mut connection = SqliteConnection::connect_with( + &sqlx::sqlite::SqliteConnectOptions::new() + .filename(namespace.database_path()) + .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal) + .synchronous(sqlx::sqlite::SqliteSynchronous::Full), + ) + .await + .unwrap(); + let mut tx = connection.begin_with("BEGIN IMMEDIATE").await.unwrap(); + for (_, _, _, sql) in schema::objects(1).unwrap() { + sqlx::raw_sql(sql).execute(&mut *tx).await.unwrap(); + } + sqlx::query("INSERT INTO stock_authority(singleton,protected) VALUES(1,?)") + .bind(root) + .execute(&mut *tx) + .await + .unwrap(); + sqlx::query("INSERT INTO stock_grants(grant_id,protected) VALUES(?,?)") + .bind(input.grant_id().as_bytes().as_slice()) + .bind(grant) + .execute(&mut *tx) + .await + .unwrap(); + sqlx::query("PRAGMA user_version=1") + .execute(&mut *tx) + .await + .unwrap(); + tx.commit().await.unwrap(); + connection.close().await.unwrap(); + drop(namespace); + let store = + NativeWorkspace::open_seller_stock(&path, input.clone(), fixture.crypto(), Arc::new(Clock)) + .await + .unwrap(); + let binding = store.authenticate(input.clone(), &proof).await.unwrap(); + assert!( + store + .stock_authority(input.clone(), &proof) + .await + .unwrap() + .inventory_checkpoint() + .is_none() + ); + let context = CommandContextData::new( + OperationId::from_bytes([7; 32]), + binding.actor(), + input.workspace_id(), + input.authority(), + 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":"retained","unit":"each","tick_scale":"0","initial_quantity":"1"}}); + let request = CreatePoolRequest::from_protected_wire( + binding, + InventoryCheckpointRef::from_host_metadata( + input.authority(), + Sequence::new(0).unwrap(), + None, + ) + .unwrap(), + &serde_json::to_vec(&wire).unwrap(), + ) + .unwrap(); + let copy = proof + .with_secret(|b| AttachmentProof::from_protected_input(b)) + .unwrap(); + assert!(matches!( + store.create_pool(request, copy).await, + Err(OperationError::UnsupportedOperation) + )); + store.close().await.unwrap(); + let mut connection = SqliteConnection::connect_with( + &sqlx::sqlite::SqliteConnectOptions::new() + .filename(path.join("stock_execution_v1.sqlite")) + .read_only(true), + ) + .await + .unwrap(); + assert_eq!(schema::admit(&mut connection).await.unwrap(), 1); + connection.close().await.unwrap(); +} diff --git a/crates/storage_sqlite/src/workspace/tests/mod.rs b/crates/storage_sqlite/src/workspace/tests/mod.rs @@ -22,7 +22,7 @@ use std::{ os::unix::fs::{DirBuilderExt, PermissionsExt, symlink}, }; -fn participant() -> PublicKey { +pub(super) fn participant() -> PublicKey { PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").unwrap() } fn selection() -> AttachmentInput { @@ -51,12 +51,15 @@ fn reference(id: &str, backend: BackendKind, version: u32) -> SecretRef { KeyVersion::new(version).unwrap(), ) } -struct CryptoFixture { +pub(super) struct CryptoFixture { _temp: tempfile::TempDir, provider: Arc<FileProvider>, } impl CryptoFixture { - fn new() -> Self { + pub(super) fn root(&self) -> std::path::PathBuf { + self._temp.path().canonicalize().unwrap() + } + pub(super) fn new() -> Self { let temp = tempfile::tempdir().unwrap(); let root = temp.path().canonicalize().unwrap(); let provider = Arc::new( @@ -83,7 +86,7 @@ impl CryptoFixture { ) .unwrap(); } - fn crypto(&self) -> WorkspaceCrypto { + pub(super) fn crypto(&self) -> WorkspaceCrypto { WorkspaceCrypto::new( self.provider.clone(), reference("grant-key", BackendKind::File, 1), diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -38,6 +38,26 @@ 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 { + CreatePool( + Box<radroots_storage::inventory::CreatePoolRequest>, + AttachmentProof, + Reply<radroots_storage::inventory::PoolCreationOutcome, OperationError>, + ), + PoolCreation( + Box<WorkspaceBinding>, + radroots_storage::inventory::InventoryCheckpointRef, + OperationId, + Option<CommandDigest>, + AttachmentProof, + Reply<Option<radroots_storage::inventory::PoolCreationReceipt>, OperationError>, + ), + Pool( + Box<WorkspaceBinding>, + radroots_storage::inventory::InventoryCheckpointRef, + radroots_domain::PoolId, + AttachmentProof, + Reply<Option<radroots_domain::stock::PoolView>, OperationError>, + ), StockAuthority( AttachmentInput, AttachmentProof, @@ -143,6 +163,15 @@ enum Job { impl Job { fn reject_recovery(self) { match self { + Self::CreatePool(_, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::PoolCreation(_, _, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::Pool(_, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } Self::StockAuthority(_, _, reply) => { let _ = reply.send(Err(WorkspaceError::RecoveryRequired)); } @@ -336,6 +365,9 @@ impl Handle { && !matches!( &job, Job::Authenticate(..) + | Job::CreatePool(..) + | Job::PoolCreation(..) + | Job::Pool(..) | Job::Revoke(..) | Job::StockAuthority(..) ) @@ -367,6 +399,64 @@ impl Handle { continue; }; match job { + Job::CreatePool(request, proof, reply) => { + let result = if kind == Kind::SellerStock { + stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + } + .create(*request, proof) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } + Job::PoolCreation( + binding, + minimum, + operation, + digest, + proof, + reply, + ) => { + let result = if kind == Kind::SellerStock { + stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + } + .creation(*binding, minimum, operation, digest, proof) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } + Job::Pool(binding, minimum, id, proof, reply) => { + let result = if kind == Kind::SellerStock { + stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + } + .pool(*binding, minimum, id, proof) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } Job::StockAuthority(selected, proof, reply) => { let result = if kind == Kind::SellerStock && !uncertain { stock::authenticate( @@ -715,8 +805,57 @@ impl Handle { self.send(Job::StockAuthority(input, proof, reply))?; result.await.map_err(|_| WorkspaceError::RecoveryRequired)? } + pub(super) async fn create_pool( + &self, + request: radroots_storage::inventory::CreatePoolRequest, + proof: AttachmentProof, + ) -> Result<radroots_storage::inventory::PoolCreationOutcome, OperationError> { + let c = request.command().context(); + let anchor = CommitAttempt::new( + c.workspace_id(), + c.operation_id(), + request.command().digest(), + None, + ); + let (reply, result) = oneshot::channel(); + self.send(Job::CreatePool(Box::new(request), proof, reply))?; + result.await.unwrap_or(Ok( + radroots_storage::inventory::PoolCreationOutcome::Unknown(anchor), + )) + } + pub(super) async fn pool_creation( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + operation: OperationId, + digest: Option<CommandDigest>, + proof: AttachmentProof, + ) -> Result<Option<radroots_storage::inventory::PoolCreationReceipt>, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::PoolCreation( + Box::new(binding), + minimum, + operation, + digest, + proof, + reply, + ))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } + pub(super) async fn pool( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + id: radroots_domain::PoolId, + proof: AttachmentProof, + ) -> Result<Option<radroots_domain::stock::PoolView>, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::Pool(Box::new(binding), minimum, id, proof, reply))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } fn send(&self, job: Job) -> Result<(), WorkspaceError> { let bytes = match &job { + Job::CreatePool(..) => 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 @@ -0,0 +1,935 @@ +use super::*; +use radroots_domain::{ + CommandContextData, Decimal, OperationId, PoolId, Quantity, listing::MeasurementUnit, + stock::PoolUnit, +}; +use radroots_protocol::command::{CapturedPoolCreation, CreatePoolInput}; +use radroots_storage::{ + command::OperationError, + inventory::{ + CreatePoolRequest, InventoryCheckpointRef, InventoryStore, PoolCreationOutcome, + PoolCreationReceipt, + }, +}; +use radroots_storage_sqlite::workspace::{SellerStockConfig, StockEnrollment}; +use sqlx::Connection; +fn proof(value: &AttachmentProof) -> AttachmentProof { + value + .with_secret(|b| AttachmentProof::from_protected_input(b)) + .unwrap() +} +fn minimum(binding: &radroots_storage::workspace::WorkspaceBinding) -> InventoryCheckpointRef { + InventoryCheckpointRef::from_host_metadata( + binding.input().authority(), + radroots_domain::Sequence::new(0).unwrap(), + None, + ) + .unwrap() +} +fn request( + binding: &radroots_storage::workspace::WorkspaceBinding, + operation: u8, + pool: u8, + label: &str, +) -> CreatePoolRequest { + let input = binding.input(); + let context = CommandContextData::new( + OperationId::from_bytes([operation; 32]), + binding.actor(), + input.workspace_id(), + input.authority(), + input.route_digest(), + None, + None, + UnixSeconds::new(150).unwrap(), + None, + ) + .unwrap(); + let quantity = Quantity::new( + "0.25".parse::<Decimal>().unwrap(), + MeasurementUnit::Kilogram, + ) + .unwrap(); + CreatePoolRequest::new( + binding.clone(), + minimum(binding), + CapturedPoolCreation::new( + context, + CreatePoolInput::new( + PoolId::from_bytes([pool; 32]), + label, + PoolUnit::new(MeasurementUnit::Kilogram, 3).unwrap(), + quantity, + ) + .unwrap(), + ) + .unwrap(), + ) + .unwrap() +} +async fn create( + f: &Fixture, +) -> ( + NativeWorkspace, + StockEnrollment, + radroots_storage::workspace::WorkspaceBinding, +) { + let enrollment = StockEnrollment::prepare( + SellerStockConfig::new( + key(), + key(), + "inventory-owner", + UnixSeconds::new(200).unwrap(), + ) + .unwrap(), + f.clock.as_ref(), + ) + .unwrap(); + let store = + NativeWorkspace::initialize_seller_stock(&f.path, &enrollment, f.crypto(), f.clock.clone()) + .await + .unwrap(); + let binding = store + .authenticate(enrollment.input().clone(), enrollment.proof()) + .await + .unwrap(); + (store, enrollment, binding) +} +fn committed(outcome: PoolCreationOutcome) -> PoolCreationReceipt { + match outcome { + PoolCreationOutcome::Committed(receipt) => *receipt, + PoolCreationOutcome::Unknown(_) => panic!("expected confirmed inventory commit"), + } +} +async fn database(f: &Fixture) -> sqlx::SqliteConnection { + sqlx::SqliteConnection::connect_with( + &sqlx::sqlite::SqliteConnectOptions::new() + .filename(f.path.join("stock_execution_v1.sqlite")) + .foreign_keys(true), + ) + .await + .unwrap() +} +#[tokio::test] +async fn real_pool_creation_commits_reopens_and_replays_original_effect_after_command_expiry() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + let original = request(&binding, 1, 2, "Carrots"); + let digest = original.command().digest(); + let receipt = committed(store.create_pool(original, proof(e.proof())).await.unwrap()); + assert_eq!(receipt.pool().balances().physical().available.get(), 250); + assert_eq!(receipt.pool().balances().introduced().get(), 250); + assert_eq!(receipt.pool().unit().scale(), 3); + assert_eq!(receipt.pool().version().get(), 1); + assert_eq!( + store + .pool( + binding.clone(), + minimum(&binding), + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await + .unwrap() + .map(|view| { + assert_eq!(view.label(), "Carrots"); + view.snapshot() + }), + Some(receipt.pool()) + ); + assert_eq!( + store + .pool_creation( + binding.clone(), + minimum(&binding), + OperationId::from_bytes([1; 32]), + Some(digest), + proof(e.proof()) + ) + .await + .unwrap(), + Some(receipt.clone()) + ); + f.clock.0.store(175, Ordering::SeqCst); + assert_eq!( + committed( + store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await + .unwrap() + ), + receipt + ); + assert!(matches!( + store + .create_pool(request(&binding, 1, 2, "Changed"), proof(e.proof())) + .await, + Err(OperationError::IdempotencyConflict) + )); + assert!(matches!( + store + .create_pool(request(&binding, 3, 4, "Late"), proof(e.proof())) + .await, + Err(OperationError::DeadlineExceeded) + )); + store.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert_eq!( + store + .pool_creation( + binding.clone(), + minimum(&binding), + OperationId::from_bytes([1; 32]), + Some(digest), + proof(e.proof()) + ) + .await + .unwrap(), + Some(receipt) + ); + store.close().await.unwrap(); + let mut connection = database(&f).await; + for table in ["stock_pools", "stock_operations", "stock_movements"] { + let sql = format!("SELECT count(*) FROM {table}"); + let count: i64 = sqlx::query_scalar(sqlx::AssertSqlSafe(sql)) + .fetch_one(&mut connection) + .await + .unwrap(); + assert_eq!(count, 1); + } + let protected: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_pools") + .fetch_one(&mut connection) + .await + .unwrap(); + assert!(!String::from_utf8_lossy(&protected).contains("Carrots")); + connection.close().await.unwrap(); +} +#[tokio::test] +async fn each_actual_inventory_write_failure_rolls_back_pool_journal_movement_and_root() { + for (table, statement) in [ + ( + "stock_pools", + "CREATE TRIGGER fail_inventory BEFORE INSERT ON stock_pools BEGIN SELECT RAISE(ABORT,'isolated fault'); END", + ), + ( + "stock_operations", + "CREATE TRIGGER fail_inventory BEFORE INSERT ON stock_operations BEGIN SELECT RAISE(ABORT,'isolated fault'); END", + ), + ( + "stock_movements", + "CREATE TRIGGER fail_inventory BEFORE INSERT ON stock_movements BEGIN SELECT RAISE(ABORT,'isolated fault'); END", + ), + ( + "stock_authority", + "CREATE TRIGGER fail_inventory BEFORE UPDATE ON stock_authority BEGIN SELECT RAISE(ABORT,'isolated fault'); END", + ), + ] { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + let mut connection = database(&f).await; + sqlx::raw_sql(statement) + .execute(&mut connection) + .await + .unwrap(); + assert!( + store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await + .is_err(), + "{table}" + ); + for name in ["stock_pools", "stock_operations", "stock_movements"] { + let sql = format!("SELECT count(*) FROM {name}"); + let count: i64 = sqlx::query_scalar(sqlx::AssertSqlSafe(sql)) + .fetch_one(&mut connection) + .await + .unwrap(); + assert_eq!(count, 0, "{table}/{name}"); + } + store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap(); + sqlx::raw_sql("DROP TRIGGER fail_inventory") + .execute(&mut connection) + .await + .unwrap(); + connection.close().await.unwrap(); + store.close().await.unwrap(); + let store = NativeWorkspace::open_seller_stock( + &f.path, + e.input().clone(), + f.crypto(), + f.clock.clone(), + ) + .await + .unwrap(); + assert!( + store + .pool( + binding.clone(), + minimum(&binding), + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await + .unwrap() + .is_none() + ); + store.close().await.unwrap(); + } +} +#[tokio::test] +async fn actual_inventory_commit_failure_is_unknown_and_fenced_until_reopen() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + let mut connection = database(&f).await; + sqlx::raw_sql("CREATE TABLE deferred_inventory_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER inventory_commit_fault AFTER INSERT ON stock_movements BEGIN INSERT INTO deferred_inventory_fault VALUES(2); END").execute(&mut connection).await.unwrap(); + let original = request(&binding, 1, 2, "Carrots"); + let digest = original.command().digest(); + let anchor = match store.create_pool(original, proof(e.proof())).await.unwrap() { + PoolCreationOutcome::Unknown(anchor) => anchor, + PoolCreationOutcome::Committed(_) => panic!("COMMIT must fail"), + }; + assert_eq!(anchor.command_digest(), digest); + assert!(anchor.transaction_id().is_some()); + assert!(matches!( + store + .pool_creation( + binding.clone(), + minimum(&binding), + OperationId::from_bytes([1; 32]), + Some(digest), + proof(e.proof()) + ) + .await, + Err(OperationError::RecoveryRequired) + )); + store.close().await.unwrap(); + sqlx::raw_sql("DROP TRIGGER inventory_commit_fault; DROP TABLE deferred_inventory_fault") + .execute(&mut connection) + .await + .unwrap(); + connection.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert!( + store + .pool_creation( + binding.clone(), + minimum(&binding), + OperationId::from_bytes([1; 32]), + Some(digest), + proof(e.proof()) + ) + .await + .unwrap() + .is_none() + ); + assert!( + store + .pool( + binding.clone(), + minimum(&binding), + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await + .unwrap() + .is_none() + ); + store.close().await.unwrap(); +} +#[tokio::test] +async fn sealed_root_detects_missing_inventory_history_instead_of_fresh_stock() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + committed( + store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await + .unwrap(), + ); + let mut connection = database(&f).await; + sqlx::raw_sql( + "DELETE FROM stock_movements; DELETE FROM stock_operations; DELETE FROM stock_pools", + ) + .execute(&mut connection) + .await + .unwrap(); + connection.close().await.unwrap(); + assert!( + store + .pool( + binding.clone(), + minimum(&binding), + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await + .is_err() + ); + store.close().await.unwrap(); + assert!( + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .is_err() + ); +} + +#[tokio::test] +async fn acknowledged_minimum_refuses_a_complete_older_database_snapshot() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + store.close().await.unwrap(); + let path = f.path.join("stock_execution_v1.sqlite"); + let original = std::fs::read(&path).unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + let receipt = committed( + store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await + .unwrap(), + ); + let acknowledged = receipt.checkpoint(); + assert_eq!(acknowledged.revision().get(), 1); + assert!(acknowledged.head().is_some()); + assert_eq!( + store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap() + .inventory_checkpoint(), + Some(acknowledged) + ); + store.close().await.unwrap(); + std::fs::write(&path, original).unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert!(matches!( + store + .pool( + binding.clone(), + acknowledged, + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + assert!(matches!( + store + .pool_creation( + binding.clone(), + acknowledged, + OperationId::from_bytes([1; 32]), + Some(receipt.attempt().command_digest()), + proof(e.proof()) + ) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + let captured = request(&binding, 3, 4, "New stock"); + let captured = CreatePoolRequest::new( + binding, + acknowledged, + CapturedPoolCreation::parse(captured.command().protected_wire()).unwrap(), + ) + .unwrap(); + assert!(matches!( + store.create_pool(captured, proof(e.proof())).await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + store.close().await.unwrap(); + let mut connection = database(&f).await; + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_pools") + .fetch_one(&mut connection) + .await + .unwrap(); + assert_eq!(count, 0); + connection.close().await.unwrap(); +} + +#[tokio::test] +async fn an_empty_pool_is_a_zero_genesis_without_a_fictitious_movement() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + let input = binding.input(); + let context = CommandContextData::new( + OperationId::from_bytes([7; 32]), + binding.actor(), + input.workspace_id(), + input.authority(), + input.route_digest(), + None, + None, + UnixSeconds::new(150).unwrap(), + None, + ) + .unwrap(); + let command = CapturedPoolCreation::new( + context, + CreatePoolInput::new( + PoolId::from_bytes([8; 32]), + "Empty", + PoolUnit::new(MeasurementUnit::Each, 0).unwrap(), + Quantity::new(Decimal::ZERO, MeasurementUnit::Each).unwrap(), + ) + .unwrap(), + ) + .unwrap(); + let digest = command.digest(); + let request = CreatePoolRequest::new(binding.clone(), minimum(&binding), command).unwrap(); + let receipt = committed(store.create_pool(request, proof(e.proof())).await.unwrap()); + assert_eq!(receipt.pool().balances().introduced().get(), 0); + assert_eq!(receipt.checkpoint().revision().get(), 1); + assert_eq!( + store + .pool_creation( + binding.clone(), + minimum(&binding), + OperationId::from_bytes([7; 32]), + Some(digest), + proof(e.proof()) + ) + .await + .unwrap(), + Some(receipt) + ); + store.close().await.unwrap(); + let mut connection = database(&f).await; + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_movements") + .fetch_one(&mut connection) + .await + .unwrap(); + assert_eq!(count, 0); + connection.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert_eq!( + store + .pool( + binding.clone(), + minimum(&binding), + PoolId::from_bytes([8; 32]), + proof(e.proof()) + ) + .await + .unwrap() + .unwrap() + .snapshot() + .balances() + .introduced() + .get(), + 0 + ); + store.close().await.unwrap(); +} + +struct AdmissionClock { + armed: std::sync::atomic::AtomicBool, + calls: AtomicU64, + next: u64, +} +impl WorkspaceClock for AdmissionClock { + fn now(&self) -> Result<UnixSeconds, WorkspaceError> { + let next = + if self.armed.load(Ordering::SeqCst) && self.calls.fetch_add(1, Ordering::SeqCst) > 0 { + self.next + } else { + 100 + }; + if next == 0 { + Err(WorkspaceError::Unavailable) + } else { + Ok(UnixSeconds::new(next).unwrap()) + } + } +} +#[tokio::test] +async fn expiry_or_clock_failure_inside_inventory_transaction_has_no_effect() { + for next in [0, 150, 200] { + let f = Fixture::new(); + let clock = Arc::new(AdmissionClock { + armed: std::sync::atomic::AtomicBool::new(false), + calls: AtomicU64::new(0), + next, + }); + let e = StockEnrollment::prepare( + SellerStockConfig::new( + key(), + key(), + "inventory-owner", + UnixSeconds::new(200).unwrap(), + ) + .unwrap(), + clock.as_ref(), + ) + .unwrap(); + let store = + NativeWorkspace::initialize_seller_stock(&f.path, &e, f.crypto(), clock.clone()) + .await + .unwrap(); + let binding = store + .authenticate(e.input().clone(), e.proof()) + .await + .unwrap(); + clock.armed.store(true, Ordering::SeqCst); + let result = store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await; + match next { + 0 => assert!(matches!( + result, + Err(OperationError::Workspace(WorkspaceError::Unavailable)) + )), + 150 => assert!(matches!(result, Err(OperationError::DeadlineExceeded))), + 200 => assert!(matches!( + result, + Err(OperationError::Workspace(WorkspaceError::GrantExpired)) + )), + _ => unreachable!(), + } + clock.armed.store(false, Ordering::SeqCst); + assert_eq!( + store + .stock_authority(e.input().clone(), e.proof()) + .await + .unwrap() + .inventory_checkpoint() + .unwrap() + .revision() + .get(), + 0 + ); + store.close().await.unwrap(); + let mut connection = database(&f).await; + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_pools") + .fetch_one(&mut connection) + .await + .unwrap(); + assert_eq!(count, 0); + connection.close().await.unwrap(); + } +} +#[tokio::test] +async fn admitted_inventory_work_survives_observer_and_close_cancellation() { + let f = Fixture::new(); + let clock = Arc::new(PausedClock { + state: std::sync::Mutex::new((false, false, false)), + changed: std::sync::Condvar::new(), + }); + let e = StockEnrollment::prepare( + SellerStockConfig::new( + key(), + key(), + "inventory-owner", + UnixSeconds::new(200).unwrap(), + ) + .unwrap(), + clock.as_ref(), + ) + .unwrap(); + let store = NativeWorkspace::initialize_seller_stock(&f.path, &e, f.crypto(), clock.clone()) + .await + .unwrap(); + let binding = store + .authenticate(e.input().clone(), e.proof()) + .await + .unwrap(); + let original = request(&binding, 1, 2, "Carrots"); + let digest = original.command().digest(); + clock.arm(); + let mut future = store.create_pool(original, proof(e.proof())); + assert!(futures::poll!(future.as_mut()).is_pending()); + clock.entered(); + drop(future); + 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, e.input().clone(), f.crypto(), f.clock.clone()) + .await, + Err(WorkspaceError::WriterActive) + )); + clock.release(); + store.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + let receipt = store + .pool_creation( + binding.clone(), + minimum(&binding), + OperationId::from_bytes([1; 32]), + Some(digest), + proof(e.proof()), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(receipt.pool().balances().physical().available.get(), 250); + assert_eq!(receipt.checkpoint().revision().get(), 1); + store.close().await.unwrap(); +} + +#[tokio::test] +async fn current_credentials_guard_pool_reads_replay_and_new_effects_after_revocation() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + let receipt = committed( + store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await + .unwrap(), + ); + let wrong = || AttachmentProof::from_protected_input(&[0xB7; 32]).unwrap(); + assert!(matches!( + store + .create_pool(request(&binding, 1, 2, "Carrots"), wrong()) + .await, + Err(OperationError::Workspace(WorkspaceError::Unauthorized)) + )); + assert!(matches!( + store + .pool( + binding.clone(), + receipt.checkpoint(), + PoolId::from_bytes([2; 32]), + wrong() + ) + .await, + Err(OperationError::Workspace(WorkspaceError::Unauthorized)) + )); + assert!(matches!( + store + .pool_creation( + binding.clone(), + receipt.checkpoint(), + OperationId::from_bytes([1; 32]), + None, + wrong() + ) + .await, + Err(OperationError::Workspace(WorkspaceError::Unauthorized)) + )); + store.revoke(e.input().clone(), e.proof()).await.unwrap(); + assert!(matches!( + store + .create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())) + .await, + Err(OperationError::Workspace(WorkspaceError::GrantRevoked)) + )); + assert!(matches!( + store + .create_pool(request(&binding, 3, 4, "New"), proof(e.proof())) + .await, + Err(OperationError::Workspace(WorkspaceError::GrantRevoked)) + )); + assert!(matches!( + store + .pool( + binding.clone(), + receipt.checkpoint(), + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await, + Err(OperationError::Workspace(WorkspaceError::GrantRevoked)) + )); + assert!(matches!( + store + .pool_creation( + binding, + receipt.checkpoint(), + OperationId::from_bytes([1; 32]), + None, + proof(e.proof()) + ) + .await, + Err(OperationError::Workspace(WorkspaceError::GrantRevoked)) + )); + store.close().await.unwrap(); + let mut conn = database(&f).await; + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_operations") + .fetch_one(&mut conn) + .await + .unwrap(); + assert_eq!(count, 1); + conn.close().await.unwrap(); +} + +#[tokio::test] +async fn simultaneous_pool_creations_serialize_identity_and_preserve_earlier_checkpoint_ancestry() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + let (left, right) = tokio::join!( + store.create_pool(request(&binding, 1, 2, "Carrots"), proof(e.proof())), + store.create_pool(request(&binding, 3, 2, "Competing"), proof(e.proof())) + ); + let first = match (left, right) { + (Ok(value), Err(OperationError::StaleState)) + | (Err(OperationError::StaleState), Ok(value)) => committed(value), + other => panic!("one serialized creation must win: {other:?}"), + }; + let next = request(&binding, 5, 6, "Parsnips"); + let next = CreatePoolRequest::new( + binding.clone(), + first.checkpoint(), + CapturedPoolCreation::parse(next.command().protected_wire()).unwrap(), + ) + .unwrap(); + let second = committed(store.create_pool(next, proof(e.proof())).await.unwrap()); + assert_eq!(first.checkpoint().revision().get(), 1); + assert_eq!(second.checkpoint().revision().get(), 2); + assert_ne!(first.checkpoint().head(), second.checkpoint().head()); + assert_eq!( + store + .pool_creation( + binding.clone(), + second.checkpoint(), + first.attempt().operation_id(), + Some(first.attempt().command_digest()), + proof(e.proof()) + ) + .await + .unwrap(), + Some(first.clone()) + ); + store.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert_eq!( + store + .pool( + binding.clone(), + first.checkpoint(), + PoolId::from_bytes([6; 32]), + proof(e.proof()) + ) + .await + .unwrap() + .unwrap() + .label(), + "Parsnips" + ); + let conflicting = InventoryCheckpointRef::from_host_metadata( + binding.input().authority(), + radroots_domain::Sequence::new(1).unwrap(), + second.checkpoint().head(), + ) + .unwrap(); + assert!(matches!( + store + .pool( + binding, + conflicting, + PoolId::from_bytes([2; 32]), + proof(e.proof()) + ) + .await, + Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + store.close().await.unwrap(); + let mut conn = database(&f).await; + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_operations") + .fetch_one(&mut conn) + .await + .unwrap(), + 2 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_pools") + .fetch_one(&mut conn) + .await + .unwrap(), + 2 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_movements") + .fetch_one(&mut conn) + .await + .unwrap(), + 2 + ); + conn.close().await.unwrap(); +} + +#[tokio::test] +async fn acknowledged_branch_cannot_be_satisfied_by_unprotected_history_index_fields() { + let f = Fixture::new(); + let (store, e, binding) = create(&f).await; + store.close().await.unwrap(); + let path = f.path.join("stock_execution_v1.sqlite"); + let genesis = std::fs::read(&path).unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + let acknowledged = committed( + store + .create_pool(request(&binding, 1, 2, "First branch"), proof(e.proof())) + .await + .unwrap(), + ) + .checkpoint(); + store.close().await.unwrap(); + // Simulate an older complete local backup and its divergent continuation. + std::fs::write(&path, genesis).unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + store + .create_pool(request(&binding, 3, 4, "Other branch"), proof(e.proof())) + .await + .unwrap(); + store + .create_pool( + request(&binding, 5, 6, "Later other branch"), + proof(e.proof()), + ) + .await + .unwrap(); + store.close().await.unwrap(); + let mut conn = database(&f).await; + sqlx::query("UPDATE stock_operations SET chain_head=? WHERE revision=1") + .bind(acknowledged.head().unwrap().as_bytes().as_slice()) + .execute(&mut conn) + .await + .unwrap(); + conn.close().await.unwrap(); + let store = + NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), f.crypto(), f.clock.clone()) + .await + .unwrap(); + assert!(matches!( + store + .pool( + binding, + acknowledged, + PoolId::from_bytes([4; 32]), + proof(e.proof()) + ) + .await, + Err(OperationError::RecoveryRequired) + | Err(OperationError::Workspace(WorkspaceError::StaleCheckpoint)) + )); + store.close().await.unwrap(); +} diff --git a/crates/storage_sqlite/tests/support/stock_authority.rs b/crates/storage_sqlite/tests/support/stock_authority.rs @@ -170,7 +170,7 @@ async fn protected_key_and_every_selection_field_refuse_without_writes() { #[tokio::test] async fn stock_catalog_and_protected_record_corruption_are_never_repaired() { for sql in [ - "PRAGMA user_version=2", + "PRAGMA user_version=99", "CREATE TABLE unexpected(value INTEGER)", "CREATE TRIGGER foreign_trigger BEFORE INSERT ON stock_grants BEGIN SELECT RAISE(ABORT,'fault'); END", "UPDATE stock_authority SET protected=zeroblob(64)", diff --git a/crates/storage_sqlite/tests/workspace_attachment.rs b/crates/storage_sqlite/tests/workspace_attachment.rs @@ -542,3 +542,6 @@ async fn unsafe_links_permissions_and_schema_are_refused_without_repair() { #[path = "support/stock_authority.rs"] mod stock_authority; + +#[path = "support/pool_creation.rs"] +mod pool_creation; diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -100,6 +100,12 @@ struct NativeSellerStockAuthority { database: String, lock: String, schema_version: u16, + retained_enrollment_versions: Vec<u16>, + authority_payload_schema: String, + pool_tick_scale_explicit: bool, + pool_tick_scale_encoding: String, + inventory_checkpoint_minimum_required: bool, + empty_pool_has_physical_movement: bool, enrollment_prepared_before_durable_creation: bool, prepared_enrollment_single_use: bool, same_connection_owner_as_outbox: bool, @@ -282,7 +288,13 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { stock.scope == "seller_stock_owner" && stock.database == "stock_execution_v1.sqlite" && stock.lock == ".stock_execution_v1.lock" - && stock.schema_version == 1 + && stock.schema_version == 2 + && stock.retained_enrollment_versions == [1] + && stock.authority_payload_schema == "radroots.seller_stock.authority.v2" + && stock.pool_tick_scale_explicit + && stock.pool_tick_scale_encoding == "canonical_integer_string" + && stock.inventory_checkpoint_minimum_required + && !stock.empty_pool_has_physical_movement && stock.enrollment_prepared_before_durable_creation && stock.prepared_enrollment_single_use && stock.same_connection_owner_as_outbox