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:
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, ¤t)?;
+ if authority.inventory.is_none() {
+ return Err(OperationError::UnsupportedOperation);
+ }
+
+ let minimum_proof = authenticate_minimum(
+ self.connection,
+ self.selected,
+ self.crypto,
+ ¤t,
+ 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(),¤t)?;
+ 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,¤t)?;
+ if let Some(operation)=absent_operation {let count:i64=sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE actor=? AND grant_id=? AND operation_id=?").bind(current.actor().participant().as_bytes().as_slice()).bind(current.input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_|OperationError::StorageFailure)?;if count!=0 {return Err(OperationError::RecoveryRequired);}}
+ if let Some(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