commit d54173b399ec1d1923bfd7766252df81e0617c30 parent ba5d7f81afcf9f046cbaf6d82b6f39fc7e8fd236 Author: triesap <tyson@radroots.org> Date: Fri, 30 Oct 2026 00:52:42 +0000 stock: inspect current physical and installed obligations - Read current pool backing and deficits at one authenticated checkpoint - Share bounded original-allocation traversal and enforce scoped read rights - Poll bounded native work concurrently while preserving control barriers - Verify native and Linux effects, recovery, admission and public APIs Diffstat:
22 files changed, 1067 insertions(+), 115 deletions(-)
diff --git a/contracts/api_baselines/radroots.txt b/contracts/api_baselines/radroots.txt @@ -203,12 +203,14 @@ pub use radroots::stock::StockDeficit pub use radroots::stock::StockEvidenceOutcome pub use radroots::stock::StockEvidenceReceipt pub use radroots::stock::StockEvidenceRequest +pub use radroots::stock::StockSnapshot pub struct radroots::stock::Stock<'a> impl<'a> radroots::stock::Stock<'a> pub async fn radroots::stock::Stock<'a>::adjust(&self, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock_correction::PoolCorrectionInput) -> radroots_execution::Result<radroots_storage::inventory::InventoryOutcome> pub async fn radroots::stock::Stock<'a>::capture_evidence(&self, &radroots_storage::inventory::evidence::StockEvidenceRequest) -> radroots_execution::Result<radroots_storage::inventory::evidence::StockEvidenceOutcome> pub async fn radroots::stock::Stock<'a>::create_pool(&self, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock::CreatePoolInput) -> radroots_execution::Result<radroots_storage::inventory::InventoryOutcome> pub async fn radroots::stock::Stock<'a>::drain_evidence(&self) -> radroots_execution::Result<()> +pub async fn radroots::stock::Stock<'a>::inspect(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId) -> radroots_execution::Result<core::option::Option<radroots_storage::inventory::snapshot::StockSnapshot>> pub async fn radroots::stock::Stock<'a>::map_option(&self, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock_mapping::MapOptionInput) -> radroots_execution::Result<radroots_storage::inventory::InventoryOutcome> pub async fn radroots::stock::Stock<'a>::operation(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>) -> radroots_execution::Result<core::option::Option<radroots_storage::inventory::InventoryReceipt>> pub async fn radroots::stock::Stock<'a>::option_mapping(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey) -> radroots_execution::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>> diff --git a/contracts/api_baselines/radroots_execution.txt b/contracts/api_baselines/radroots_execution.txt @@ -130,6 +130,7 @@ pub async fn radroots_execution::session::ClientSession<H>::capture_stock_eviden pub async fn radroots_execution::session::ClientSession<H>::correct_stock_pool(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock_correction::PoolCorrectionInput) -> radroots_execution::Result<radroots_storage::inventory::InventoryOutcome> pub async fn radroots_execution::session::ClientSession<H>::create_stock_pool(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock::CreatePoolInput) -> radroots_execution::Result<radroots_storage::inventory::InventoryOutcome> pub async fn radroots_execution::session::ClientSession<H>::drain_stock_evidence(&self) -> radroots_execution::Result<()> +pub async fn radroots_execution::session::ClientSession<H>::inspect_stock_pool(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId) -> radroots_execution::Result<core::option::Option<radroots_storage::inventory::snapshot::StockSnapshot>> pub async fn radroots_execution::session::ClientSession<H>::inventory_operation(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>) -> radroots_execution::Result<core::option::Option<radroots_storage::inventory::InventoryReceipt>> pub async fn radroots_execution::session::ClientSession<H>::map_stock_option(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_protocol::command::stock_mapping::MapOptionInput) -> radroots_execution::Result<radroots_storage::inventory::InventoryOutcome> pub async fn radroots_execution::session::ClientSession<H>::prepare_stock_acceptance(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_protocol::command::order_acceptance::AcceptOrderInput) -> radroots_execution::Result<radroots_storage::inventory::acceptance::StockAcceptanceOutcome> diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -1681,12 +1681,21 @@ impl radroots_storage::inventory::StockRewrapState pub const fn radroots_storage::inventory::StockRewrapState::admission(&self) -> radroots_storage::inventory::StockRewrapAdmission pub const fn radroots_storage::inventory::StockRewrapState::envelope(&self) -> core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt> pub fn radroots_storage::inventory::StockRewrapState::from_store_report(radroots_storage::inventory::StockRewrapAdmission, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub struct radroots_storage::inventory::StockSnapshot +impl radroots_storage::inventory::StockSnapshot +pub const fn radroots_storage::inventory::StockSnapshot::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub fn radroots_storage::inventory::StockSnapshot::from_host_metadata(radroots_domain::stock::PoolView, radroots_domain::stock::obligation::ObligationBacking, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::inventory::StockSnapshot::installed_obligations(&self) -> radroots_domain::stock::obligation::ObligationBacking +pub const fn radroots_storage::inventory::StockSnapshot::pool(&self) -> &radroots_domain::stock::PoolView +impl core::fmt::Debug for radroots_storage::inventory::StockSnapshot +pub fn radroots_storage::inventory::StockSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub trait radroots_storage::inventory::InventoryStore: radroots_storage::workspace::WorkspaceStore pub fn radroots_storage::inventory::InventoryStore::abort_proven_unissued(&self, radroots_storage::inventory::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockAbortOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::capture_stock_envelope<'a>(&'a self, radroots_storage::inventory::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::capture_stock_evidence<'a>(&'a self, &'a radroots_storage::inventory::StockEvidenceRequest, &'a radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEvidenceOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::capture_stock_rewrap<'a>(&'a self, radroots_storage::inventory::StockRewrapRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::execute_inventory(&self, radroots_storage::inventory::InventoryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::InventoryOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::inspect_stock(&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_storage::inventory::StockSnapshot>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::inventory_operation(&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::InventoryReceipt>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::option_mapping(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>, 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>> diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -501,6 +501,7 @@ pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_stock_envelo pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_stock_evidence<'a>(&'a self, &'a radroots_storage::inventory::evidence::StockEvidenceRequest, &'a radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::evidence::StockEvidenceOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_stock_rewrap<'a>(&'a self, radroots_storage::inventory::rewrap::StockRewrapRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::delivery::private::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::envelope::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::execute_inventory(&self, radroots_storage::inventory::InventoryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::InventoryOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::inspect_stock(&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_storage::inventory::snapshot::StockSnapshot>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::inventory_operation(&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::InventoryReceipt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::option_mapping(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>, 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>> diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -1092,6 +1092,19 @@ "first_issuance_seconds": 120 }, "stock_accounting": { + "native_inspection": { + "model_owner": "radroots_storage.inventory.StockSnapshot", + "facade_method": "Stock.inspect", + "storage_port": "InventoryStore.inspect_stock", + "supported_catalogs": [19], + "worker_charge_bytes": 1048576, + "same_checkpoint_required": true, + "original_allocation_required": true, + "read_pools_and_operations_required": true, + "pending_claims_are_installed": false, + "query_creates_store_effects": false, + "reports_global_business_completeness": false + }, "value_owner": "radroots_domain.stock", "scope": "one_fixed_pool_unit", "obligation_equation": "remaining = backed + deficit", @@ -1133,6 +1146,9 @@ "selected_workspace_views_share_owner": true, "exact_owned_attachment_required": true, "bounded_task_host_required": true, + "native_accepted_work_max": 32, + "native_pending_work_blocks_queries": false, + "native_controls_drain_prior_work": true, "observer_loss_cancels_accepted_work": false, "close_drains_before_workspace_disposal": true, "stock_signer_or_transport_constructed": false diff --git a/crates/execution/src/session/client_inventory.rs b/crates/execution/src/session/client_inventory.rs @@ -304,6 +304,24 @@ impl<H: SessionHost + 'static> ClientSession<H> { .await } + /// Reads current physical and installed backing/deficit together. This + /// starts no signer, command capture or physical stock effect. + pub async fn inspect_stock_pool( + &self, + store: Shared<dyn InventoryStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + pool: PoolId, + ) -> crate::Result<Option<radroots_storage::inventory::StockSnapshot>> { + self.run_stock( + scope, + OperationContext::proposed(None), + move |binding, proof| { + Box::pin(async move { store.inspect_stock(binding, minimum, pool, proof).await }) + }, + ) + .await + } /// Reads a private pool; a missing row never constructs stock or authority. pub async fn stock_pool( &self, diff --git a/crates/radroots/src/native_stock_deficit_tests.rs b/crates/radroots/src/native_stock_deficit_tests.rs @@ -6,6 +6,255 @@ use radroots_domain::{ }; use radroots_storage::inventory::InventoryReceipt; +#[tokio::test] +async fn current_inspection_reports_aggregate_backing_instead_of_old_receipt_totals() { + use AvailableStockCorrection::{Add, Remove, Spoil}; + use sqlx::Connection; + let r = Rig::new().await; + let (_command, _status) = r.accept().await; + let (_, _, minimum) = r.minima().await; + let initial = r + .client + .stock(&r.scope) + .inspect(minimum, PoolId::from_bytes([80; 32])) + .await + .unwrap() + .unwrap(); + assert_eq!(initial.checkpoint(), minimum); + assert_eq!(initial.installed_obligations().remaining().get(), 3); + assert_eq!(initial.installed_obligations().backed().get(), 3); + assert_eq!(initial.installed_obligations().deficit(), StockTicks::ZERO); + let first = committed( + correct( + &r, + 130, + initial.pool().snapshot().version().get(), + Spoil, + "8", + "first synthetic loss", + ) + .await + .unwrap(), + ); + let current = r + .client + .stock(&r.scope) + .inspect(first.checkpoint(), first.pool().id()) + .await + .unwrap() + .unwrap(); + assert_eq!(current.checkpoint(), first.checkpoint()); + assert_eq!(current.installed_obligations().remaining().get(), 3); + assert_eq!(current.installed_obligations().backed().get(), 2); + assert_eq!(current.installed_obligations().deficit().get(), 1); + let second = committed( + correct( + &r, + 131, + first.pool().version().get(), + Remove, + "1", + "second synthetic loss", + ) + .await + .unwrap(), + ); + let added = committed( + correct( + &r, + 132, + second.pool().version().get(), + Add, + "2", + "explicit new source", + ) + .await + .unwrap(), + ); + let current = r + .client + .stock(&r.scope) + .inspect(added.checkpoint(), added.pool().id()) + .await + .unwrap() + .unwrap(); + assert_eq!(first.deficits()[0].backing().deficit().get(), 1); + assert_eq!(current.installed_obligations().remaining().get(), 3); + assert_eq!(current.installed_obligations().backed().get(), 1); + assert_eq!(current.installed_obligations().deficit().get(), 2); + assert_eq!( + current + .pool() + .snapshot() + .balances() + .physical() + .available + .get(), + 2 + ); + assert_eq!( + format!("{current:?}"), + "StockSnapshot(<private current metadata>)" + ); + // Read fences do not append operations or reinterpret absent projections. + assert_eq!(r.minima().await.2, added.checkpoint()); + let mut fault = sqlx::SqliteConnection::connect(&format!( + "sqlite://{}", + r._temp + .path() + .join("stock/stock_execution_v1.sqlite") + .display() + )) + .await + .unwrap(); + sqlx::query("DELETE FROM stock_deficits WHERE operation_id=?") + .bind(first.attempt().operation_id().as_bytes().as_slice()) + .execute(&mut fault) + .await + .unwrap(); + assert_eq!( + r.client + .stock(&r.scope) + .inspect(added.checkpoint(), added.pool().id()) + .await + .unwrap_err() + .code(), + crate::Code::RecoveryRequired + ); + let original = first.deficits()[0]; + sqlx::query("INSERT INTO stock_deficits(actor,operation_id,acceptance_id,installation_id,line_id,pool_id) VALUES(?,?,?,?,?,?)") + .bind(r.enrollment.input().participant().as_bytes().as_slice()).bind(first.attempt().operation_id().as_bytes().as_slice()) + .bind(original.acceptance().as_bytes().as_slice()).bind(original.installation().as_bytes().as_slice()) + .bind(original.line().as_bytes().as_slice()).bind(original.pool().as_bytes().as_slice()).execute(&mut fault).await.unwrap(); + fault.close().await.unwrap(); + r.clock.0.store(0, Ordering::SeqCst); + assert!( + r.client + .stock(&r.scope) + .inspect(added.checkpoint(), added.pool().id()) + .await + .is_err() + ); + r.clock.0.store(150, Ordering::SeqCst); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 2); + assert_eq!(r.io.sent.lock().unwrap().len(), 2); + r.client.close().await.unwrap(); + let crypto = WorkspaceCrypto::new( + r.vault.clone(), + SecretRef::new( + SecretId::parse("workspace-key").unwrap(), + BackendKind::File, + KeyVersion::new(1).unwrap(), + ), + SecretMaterial::from_slice(&[0x41; 32]).unwrap(), + AccessPolicy::standard(), + ) + .unwrap(); + let reopened = NativeWorkspace::open_seller_stock( + &r._temp.path().join("stock"), + r.enrollment.input().clone(), + crypto, + r.clock.clone(), + ) + .await + .unwrap(); + let binding = reopened + .authenticate(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap(); + let recovered = reopened + .inspect_stock( + binding, + added.checkpoint(), + added.pool().id(), + proof(r.enrollment.proof()), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(recovered, current); + reopened.close().await.unwrap(); +} + +#[tokio::test] +async fn current_inspection_keeps_pending_claims_separate_from_installed_obligations() { + let r = Arc::new(Rig::new().await); + let (_, _, minimum) = r.minima().await; + assert!( + r.client + .stock(&r.scope) + .inspect(minimum, PoolId::from_bytes([99; 32])) + .await + .unwrap() + .is_none() + ); + r.control.pause_peer.store(true, Ordering::SeqCst); + let task = { + let r = r.clone(); + tokio::spawn(async move { r.accept().await }) + }; + r.control.entered.notified().await; + let (_, _, minimum) = r.minima().await; + let signs = r.control.signs.load(Ordering::SeqCst); + let pending = r + .client + .stock(&r.scope) + .inspect(minimum, PoolId::from_bytes([80; 32])) + .await + .unwrap() + .unwrap(); + assert_eq!( + pending + .pool() + .snapshot() + .balances() + .physical() + .preparatory_hold + .get(), + 3 + ); + assert_eq!( + pending + .pool() + .snapshot() + .balances() + .physical() + .available + .get(), + 7 + ); + assert_eq!( + pending.installed_obligations().remaining(), + StockTicks::ZERO + ); + assert_eq!(pending.installed_obligations().backed(), StockTicks::ZERO); + assert_eq!(pending.installed_obligations().deficit(), StockTicks::ZERO); + assert_eq!(r.control.signs.load(Ordering::SeqCst), signs); + r.control.release.notify_one(); + task.await.unwrap(); + let (_, _, minimum) = r.minima().await; + let installed = r + .client + .stock(&r.scope) + .inspect(minimum, pending.pool().snapshot().id()) + .await + .unwrap() + .unwrap(); + assert_eq!(installed.installed_obligations().remaining().get(), 3); + assert_eq!(installed.installed_obligations().backed().get(), 3); + assert_eq!( + installed + .pool() + .snapshot() + .balances() + .physical() + .preparatory_hold, + StockTicks::ZERO + ); + r.client.close().await.unwrap(); +} + async fn correct( r: &Rig, id: u8, @@ -193,6 +442,15 @@ async fn failed_native_correction(uncertain_commit: bool) { #[tokio::test] async fn native_inventory_proof_work_reserves_the_live_queue_budget_until_sql_confirmation() { + inventory_read_budget(false).await; +} + +#[tokio::test] +async fn native_inspection_reserves_the_live_queue_budget_until_sql_confirmation() { + inventory_read_budget(true).await; +} + +async fn inventory_read_budget(inspect: bool) { use sqlx::Connection; let r = Rig::new().await; let (_, _, minimum) = r.minima().await; @@ -207,25 +465,33 @@ async fn native_inventory_proof_work_reserves_the_live_queue_budget_until_sql_co .await .unwrap(); let transaction = blocker.begin_with("BEGIN IMMEDIATE").await.unwrap(); - let mut reads: Vec<_> = (0..4) - .map(|_| { - Box::pin(r.native.pool( - r.scope.binding().clone(), - minimum, - pool, - proof(r.enrollment.proof()), - )) - }) - .collect(); + let read = || async { + if inspect { + r.native + .inspect_stock( + r.scope.binding().clone(), + minimum, + pool, + proof(r.enrollment.proof()), + ) + .await + .map(|value| value.map(|value| value.pool().clone())) + } else { + r.native + .pool( + r.scope.binding().clone(), + minimum, + pool, + proof(r.enrollment.proof()), + ) + .await + } + }; + let mut reads: Vec<_> = (0..4).map(|_| Box::pin(read())).collect(); for read in &mut reads { assert!(futures::poll!(read.as_mut()).is_pending()); } - let fifth = r.native.pool( - r.scope.binding().clone(), - minimum, - pool, - proof(r.enrollment.proof()), - ); + let fifth = read(); let error = tokio::time::timeout(std::time::Duration::from_secs(1), fifth) .await .expect("full queue must refuse without waiting for its blocked writer") diff --git a/crates/radroots/src/native_tasks.rs b/crates/radroots/src/native_tasks.rs @@ -1,10 +1,20 @@ //! One explicitly started native executor for library-owned command futures. -use futures::{FutureExt, future::Shared}; +use futures::{ + FutureExt, StreamExt, + future::{Either, Shared, select}, + stream::FuturesUnordered, +}; use radroots_execution::{ Code, Error, OperationContext, RetryClass, session::{HostFuture, tasks::TaskHost}, }; -use std::{sync::Mutex, thread::JoinHandle}; +use std::{ + sync::{ + Arc, Mutex, + atomic::{AtomicUsize, Ordering}, + }, + thread::JoinHandle, +}; use tokio::sync::{mpsc, oneshot}; const CAPACITY: usize = 32; @@ -56,6 +66,13 @@ struct State { pub(crate) struct NativeTasks { state: Mutex<State>, closing: futures::lock::Mutex<()>, + admitted: Arc<AtomicUsize>, +} +struct WorkLease(Arc<AtomicUsize>); +impl Drop for WorkLease { + fn drop(&mut self) { + self.0.fetch_sub(1, Ordering::AcqRel); + } } fn completion(receiver: oneshot::Receiver<crate::Result<()>>) -> Completion { let future: HostFuture<'static, crate::Result<()>> = @@ -78,14 +95,32 @@ fn run_worker( }; let _ = ready.send(Ok(())); runtime.block_on(async move { - while let Some(job) = receiver.recv().await { + let mut active = FuturesUnordered::new(); + loop { + let next = if active.is_empty() { + receiver.recv().await + } else { + match select(Box::pin(receiver.recv()), active.next()).await { + Either::Left((job, _)) => job, + Either::Right((_, _)) => continue, + } + }; + let Some(job) = next else { + while active.next().await.is_some() {} + break; + }; match job { - Job::Work(task) => task.await, + Job::Work(task) => active.push(task), Job::Control(task, reply) => { + // Later submissions cannot cross a control barrier. + while active.next().await.is_some() {} let result = task.await; let _ = reply.send(result); } - Job::Stop => break, + Job::Stop => { + while active.next().await.is_some() {} + break; + } } } }); @@ -301,6 +336,21 @@ impl TaskHost for NativeTasks { return Err(UNAVAILABLE); } let running = state.running.as_ref().ok_or(UNAVAILABLE)?; + if self + .admitted + .try_update(Ordering::AcqRel, Ordering::Acquire, |used| { + used.checked_add(1).filter(|next| *next <= CAPACITY) + }) + .is_err() + { + drop(state); + return Err(UNAVAILABLE); + } + let lease = WorkLease(self.admitted.clone()); + let task = Box::pin(async move { + task.await; + drop(lease); + }); let result = running.sender.try_send(Job::Work(task)); drop(state); result.map_err(|_| UNAVAILABLE) @@ -509,6 +559,34 @@ mod tests { } #[test] + fn dropping_the_driver_does_not_cancel_accepted_pending_work() { + let tasks = NativeTasks::new(); + block_on(tasks.start()).unwrap(); + let (started, observed) = std::sync::mpsc::sync_channel(1); + let (release, wait) = oneshot::channel(); + let calls = Arc::new(AtomicUsize::new(0)); + let completed = calls.clone(); + tasks + .submit(Box::pin(async move { + started.send(()).unwrap(); + wait.await.unwrap(); + completed.fetch_add(1, Ordering::SeqCst); + })) + .unwrap(); + observed.recv_timeout(Duration::from_secs(10)).unwrap(); + let (done, thread) = { + let mut state = tasks.state.lock().unwrap(); + let running = state.running.as_mut().unwrap(); + (running.done.clone(), running.thread.take().unwrap()) + }; + drop(tasks); + release.send(()).unwrap(); + block_on(done).unwrap(); + thread.join().unwrap(); + assert_eq!(calls.load(Ordering::SeqCst), 1); + } + + #[test] fn accepted_tasks_and_control_survive_lost_observation_on_the_actual_native_executor() { let tasks = NativeTasks::new(); let count = Arc::new(AtomicUsize::new(0)); @@ -589,31 +667,88 @@ mod tests { } } #[test] + fn pending_work_allows_reads_but_controls_and_later_work_keep_their_barrier() { + let tasks = NativeTasks::new(); + block_on(tasks.start()).unwrap(); + let (release, wait) = oneshot::channel(); + tasks + .submit(Box::pin(async move { + wait.await.unwrap(); + })) + .unwrap(); + let (read, observed) = std::sync::mpsc::sync_channel(1); + tasks + .submit(Box::pin(async move { + read.send(()).unwrap(); + })) + .unwrap(); + observed.recv_timeout(Duration::from_secs(10)).unwrap(); + let (controlled, control_seen) = std::sync::mpsc::sync_channel(1); + let (release_control, wait_control) = oneshot::channel(); + let mut control = Box::pin(tasks.control( + ControlKind::Drain, + Box::pin(async move { + controlled.send(()).unwrap(); + wait_control.await.unwrap(); + Ok(()) + }), + )); + pending(control.as_mut()); + let (later, later_seen) = std::sync::mpsc::sync_channel(1); + tasks + .submit(Box::pin(async move { + later.send(()).unwrap(); + })) + .unwrap(); + assert!(matches!( + control_seen.try_recv(), + Err(std::sync::mpsc::TryRecvError::Empty) + )); + release.send(()).unwrap(); + control_seen.recv_timeout(Duration::from_secs(10)).unwrap(); + assert!(matches!( + later_seen.try_recv(), + Err(std::sync::mpsc::TryRecvError::Empty) + )); + release_control.send(()).unwrap(); + block_on(control).unwrap(); + later_seen.recv_timeout(Duration::from_secs(10)).unwrap(); + block_on(tasks.close()).unwrap(); + assert_eq!(tasks.admitted.load(Ordering::Acquire), 0); + } + #[test] fn native_queue_refusal_drops_captured_roots_outside_the_gate_and_close_drains_accepted_tasks() { let tasks = Arc::new(NativeTasks::new()); block_on(tasks.start()).unwrap(); let (ready, observed) = std::sync::mpsc::sync_channel(1); let (release, wait) = oneshot::channel(); + let wait = wait.shared(); + let first_wait = wait.clone(); tasks .submit(Box::pin(async move { ready.send(()).unwrap(); - wait.await.unwrap(); + first_wait.await.unwrap(); })) .unwrap(); observed.recv_timeout(Duration::from_secs(10)).unwrap(); let count = Arc::new(AtomicUsize::new(0)); let (finished, completed) = oneshot::channel(); let mut finished = Some(finished); - for index in 0..CAPACITY { + let (started, observed) = std::sync::mpsc::sync_channel(CAPACITY); + for index in 0..CAPACITY - 1 { let count = count.clone(); - let finished = if index + 1 == CAPACITY { + let wait = wait.clone(); + let started = started.clone(); + let finished = if index + 2 == CAPACITY { finished.take() } else { None }; tasks .submit(Box::pin(async move { + started.send(()).unwrap(); + wait.await.unwrap(); count.fetch_add(1, Ordering::SeqCst); if let Some(finished) = finished { let _ = finished.send(()); @@ -621,6 +756,11 @@ mod tests { })) .unwrap(); } + // All32 work slots are active; control/stop admission must not depend + // on whether the worker happened to empty its channel before polling. + for _ in 0..CAPACITY - 1 { + observed.recv_timeout(Duration::from_secs(10)).unwrap(); + } let drops = Arc::new(AtomicUsize::new(0)); let probe = ReentrantDrop(tasks.clone(), drops.clone()); assert!( @@ -631,9 +771,12 @@ mod tests { .is_err() ); assert_eq!(drops.load(Ordering::SeqCst), 1); - assert!(block_on(tasks.control(ControlKind::Drain, Box::pin(async { Ok(()) }))).is_err()); - assert!(block_on(tasks.close()).is_err()); - tasks.quiesce(); + assert_eq!(tasks.admitted.load(Ordering::Acquire), CAPACITY); + let mut drain = Box::pin(tasks.control(ControlKind::Drain, Box::pin(async { Ok(()) }))); + pending(drain.as_mut()); + let mut closing = Box::pin(tasks.close()); + pending(closing.as_mut()); + drop(closing); let probe = ReentrantDrop(tasks.clone(), drops.clone()); assert!( tasks @@ -645,8 +788,9 @@ mod tests { assert_eq!(drops.load(Ordering::SeqCst), 2); release.send(()).unwrap(); block_on(completed).unwrap(); - block_on(tasks.control(ControlKind::Drain, Box::pin(async { Ok(()) }))).unwrap(); + block_on(drain).unwrap(); block_on(tasks.close()).unwrap(); - assert_eq!(count.load(Ordering::SeqCst), CAPACITY); + assert_eq!(count.load(Ordering::SeqCst), CAPACITY - 1); + assert_eq!(tasks.admitted.load(Ordering::Acquire), 0); } } diff --git a/crates/radroots/src/stock.rs b/crates/radroots/src/stock.rs @@ -6,7 +6,7 @@ use radroots_domain::{ }; pub use radroots_protocol::command::{CreatePoolInput, MapOptionInput, PoolCorrectionInput}; pub use radroots_storage::inventory::{ - InventoryCheckpointRef, InventoryOutcome, InventoryReceipt, StockDeficit, + InventoryCheckpointRef, InventoryOutcome, InventoryReceipt, StockDeficit, StockSnapshot, }; pub use radroots_storage::inventory::{ StockEvidenceOutcome, StockEvidenceReceipt, StockEvidenceRequest, @@ -118,6 +118,18 @@ impl<'a> Stock<'a> { ) .await } + /// Inspects current physical stock and pool-backed installed obligations at + /// one confirmed checkpoint. Historical correction receipts are separate. + pub async fn inspect( + &self, + minimum: InventoryCheckpointRef, + pool: PoolId, + ) -> Result<Option<StockSnapshot>> { + self.client + .session + .inspect_stock_pool(self.client.inventory()?, &self.scope, minimum, pool) + .await + } /// Reads the actual protected pool under an independently retained minimum. pub async fn pool( &self, diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs @@ -10,6 +10,8 @@ use radroots_transport::BoxFuture; mod abort; mod acceptance; mod deficit; +mod snapshot; +pub use snapshot::StockSnapshot; mod delivery; pub use deficit::StockDeficit; mod delivery_state; @@ -536,6 +538,17 @@ pub trait InventoryStore: WorkspaceStore { digest: Option<CommandDigest>, proof: AttachmentProof, ) -> BoxFuture<'_, Result<Option<InventoryReceipt>, OperationError>>; + /// Reads one current physical/installed-backing snapshot. Unsupported hosts + /// refuse; a physical-only read must never be filled with invented totals. + fn inspect_stock( + &self, + _binding: WorkspaceBinding, + _minimum: InventoryCheckpointRef, + _id: PoolId, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<StockSnapshot>, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } fn pool( &self, binding: WorkspaceBinding, diff --git a/crates/storage/src/inventory/snapshot.rs b/crates/storage/src/inventory/snapshot.rs @@ -0,0 +1,56 @@ +use super::{InventoryCheckpointRef, OperationError}; +use radroots_domain::stock::{ObligationBacking, PoolView}; + +/// Current selected-executor physical stock and its pool-backed installed +/// obligations at one confirmed inventory checkpoint. Preparatory claims and +/// never-stock-backed future promises are not installed obligation totals. +/// This metadata grants no authority, completeness beyond this pool, or effect. +#[derive(Clone, Eq, PartialEq)] +pub struct StockSnapshot { + pool: PoolView, + installed: ObligationBacking, + checkpoint: InventoryCheckpointRef, +} +impl StockSnapshot { + /// Reconstructs checked metadata only. The qualified store must authenticate + /// original allocations, current backing, permissions and the final fence. + pub fn from_host_metadata( + pool: PoolView, + installed: ObligationBacking, + checkpoint: InventoryCheckpointRef, + ) -> Result<Self, OperationError> { + let physical = pool.snapshot().balances().physical(); + let held = physical + .committed_hold + .checked_add(physical.physical_quarantine) + .map_err(|_| OperationError::RecoveryRequired)?; + if pool.snapshot().version().get() == 0 + || checkpoint.revision().get() == 0 + || installed.remaining() > pool.snapshot().balances().introduced() + || installed.backed() > held + { + return Err(OperationError::RecoveryRequired); + } + Ok(Self { + pool, + installed, + checkpoint, + }) + } + pub const fn pool(&self) -> &PoolView { + &self.pool + } + /// Remaining = backed + deficit for known pool-backed installed obligations. + /// Pending issuance risk remains represented by the physical held categories. + pub const fn installed_obligations(&self) -> ObligationBacking { + self.installed + } + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } +} +impl core::fmt::Debug for StockSnapshot { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("StockSnapshot(<private current metadata>)") + } +} diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs @@ -1488,6 +1488,21 @@ impl radroots_storage::inventory::InventoryStore for NativeWorkspace { .inventory_operation(binding, minimum, operation, digest, proof), ) } + fn inspect_stock( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + id: radroots_domain::PoolId, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result< + Option<radroots_storage::inventory::StockSnapshot>, + radroots_storage::command::OperationError, + >, + > { + Box::pin(self.worker.inspect_stock(binding, minimum, id, proof)) + } fn pool( &self, binding: WorkspaceBinding, diff --git a/crates/storage_sqlite/src/workspace/stock/inventory.rs b/crates/storage_sqlite/src/workspace/stock/inventory.rs @@ -1,10 +1,12 @@ //! Owner-private inventory effects on the existing connection owner. pub(in crate::workspace) mod abort; pub(in crate::workspace) mod acceptance; +mod allocations; pub(in crate::workspace::stock) mod backing; pub(super) mod checkpoint; mod codec; pub(in crate::workspace::stock) mod deficit; +mod inspection; pub(in crate::workspace) mod installation; mod mapping; mod plan; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/allocations.rs b/crates/storage_sqlite/src/workspace/stock/inventory/allocations.rs @@ -0,0 +1,126 @@ +//! Bounded traversal of actual original T0/T2 allocations, shared by loss +//! planning and current inspection. SQL pointers never establish the claim. +use super::*; +use radroots_domain::stock::{ObligationBacking, StockAllocation}; + +pub(super) struct InstalledAllocation { + pub acceptance: OperationId, + pub installation: OperationId, + pub allocation: StockAllocation, +} +impl InstalledAllocation { + pub async fn backing( + &self, + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + before_revision: u64, + ) -> Result<ObligationBacking, OperationError> { + let prior = super::deficit::prior_quantity( + connection, + input, + crypto, + self.acceptance, + self.installation, + self.allocation.line_id(), + self.allocation.pool_id(), + before_revision, + ) + .await?; + let backed = self + .allocation + .ticks() + .checked_sub(prior) + .map_err(|_| OperationError::RecoveryRequired)?; + ObligationBacking::new(self.allocation.ticks(), backed, prior) + .map_err(|_| OperationError::RecoveryRequired) + } +} + +pub(super) struct InstalledCursor { + pool: PoolId, + before_revision: u64, + revision: u64, + acceptance: Option<OperationId>, + installation: Option<OperationId>, + pending: std::vec::IntoIter<StockAllocation>, +} +impl InstalledCursor { + pub fn new(pool: PoolId, before_revision: u64) -> Result<Self, OperationError> { + if before_revision == 0 || before_revision > i64::MAX as u64 { + return Err(WorkspaceError::Capacity.into()); + } + Ok(Self { + pool, + before_revision, + revision: 0, + acceptance: None, + installation: None, + pending: Vec::new().into_iter(), + }) + } + pub async fn next( + &mut self, + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + ) -> Result<Option<InstalledAllocation>, OperationError> { + loop { + if let Some(allocation) = self.pending.next() { + if allocation.pool_id() != self.pool { + continue; + } + return Ok(Some(InstalledAllocation { + acceptance: self.acceptance.ok_or(OperationError::RecoveryRequired)?, + installation: self.installation.ok_or(OperationError::RecoveryRequired)?, + allocation, + })); + } + let row = sqlx::query("SELECT revision,CASE WHEN length(operation_id)=32 THEN operation_id END FROM stock_operations WHERE family=6 AND revision>? AND revision<? ORDER BY revision LIMIT 1") + .bind(self.revision as i64).bind(self.before_revision as i64) + .fetch_optional(&mut *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 entry: Vec<u8> = row + .try_get::<Option<Vec<u8>>, _>(1) + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + if revision <= 0 { + return Err(OperationError::RecoveryRequired); + } + self.revision = revision as u64; + let entry = OperationId::from_bytes( + entry + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let installed = Box::pin(super::installation::read_entry( + connection, input, crypto, entry, + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if installed.frame.header.revision.get() != self.revision + || installed.frame.header.actor.participant() != input.participant() + { + return Err(OperationError::RecoveryRequired); + } + let acceptance = installed + .frame + .header + .related_operation + .ok_or(OperationError::RecoveryRequired)?; + let original = Box::pin(super::acceptance::codec::read( + connection, input, crypto, acceptance, + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + self.pending = original.original_allocations()?.into_iter(); + self.acceptance = Some(acceptance); + self.installation = Some(entry); + } + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/deficit.rs b/crates/storage_sqlite/src/workspace/stock/inventory/deficit.rs @@ -85,94 +85,36 @@ pub(super) async fn plan( if remaining > physical.committed_hold { return Err(OperationError::StaleState); } - let mut cursor = 0_u64; + let mut cursor = super::allocations::InstalledCursor::new(pool.id(), before_revision)?; let mut losses = Vec::new(); while remaining != StockTicks::ZERO { - let row = sqlx::query("SELECT revision,CASE WHEN length(operation_id)=32 THEN operation_id END FROM stock_operations WHERE family=6 AND revision>? AND revision<? ORDER BY revision LIMIT 1") - .bind(cursor as i64).bind(before_revision as i64).fetch_optional(&mut *connection).await - .map_err(|_| OperationError::RecoveryRequired)? - .ok_or(OperationError::RecoveryRequired)?; - let revision: i64 = row - .try_get(0) - .map_err(|_| OperationError::RecoveryRequired)?; - let entry: Vec<u8> = row - .try_get::<Option<Vec<u8>>, _>(1) - .map_err(|_| OperationError::RecoveryRequired)? - .ok_or(OperationError::RecoveryRequired)?; - if revision <= 0 { - return Err(OperationError::RecoveryRequired); - } - cursor = revision as u64; - let entry = OperationId::from_bytes( - entry - .try_into() - .map_err(|_| OperationError::RecoveryRequired)?, - ); - let installed = Box::pin(super::installation::read_entry( - connection, input, crypto, entry, - )) - .await? - .ok_or(OperationError::RecoveryRequired)?; - if installed.frame.header.revision.get() != cursor - || installed.frame.header.actor.participant() != input.participant() - { - return Err(OperationError::RecoveryRequired); - } - let acceptance = installed - .frame - .header - .related_operation + let allocation = Box::pin(cursor.next(connection, input, crypto)) + .await? .ok_or(OperationError::RecoveryRequired)?; - let original = Box::pin(super::acceptance::codec::read( - connection, input, crypto, acceptance, - )) - .await? - .ok_or(OperationError::RecoveryRequired)?; - for allocation in original.original_allocations()? { - if allocation.pool_id() != pool.id() { - continue; - } - let prior = prior_quantity( - connection, - input, - crypto, - acceptance, - entry, - allocation.line_id(), - pool.id(), - before_revision, - ) + let before = allocation + .backing(connection, input, crypto, before_revision) .await?; - let backed = allocation - .ticks() - .checked_sub(prior) - .map_err(|_| OperationError::RecoveryRequired)?; - if backed == StockTicks::ZERO { - continue; - } - if losses.len() == MAX_LOSSES { - return Err(WorkspaceError::Capacity.into()); - } - let quantity = remaining.min(backed); - let before = ObligationBacking::new(allocation.ticks(), backed, prior) - .map_err(|_| OperationError::RecoveryRequired)?; - let after = before - .lose_backing(quantity) - .map_err(|_| OperationError::RecoveryRequired)?; - losses.push(Loss { - acceptance, - installation: entry, - line: allocation.line_id(), - before, - after, - }); - remaining = remaining - .checked_sub(quantity) - .map_err(|_| OperationError::RecoveryRequired)?; - if remaining == StockTicks::ZERO { - break; - } + let backed = before.backed(); + if backed == StockTicks::ZERO { + continue; + } + if losses.len() == MAX_LOSSES { + return Err(WorkspaceError::Capacity.into()); } + let quantity = remaining.min(backed); + let after = before + .lose_backing(quantity) + .map_err(|_| OperationError::RecoveryRequired)?; + losses.push(Loss { + acceptance: allocation.acceptance, + installation: allocation.installation, + line: allocation.allocation.line_id(), + before, + after, + }); + remaining = remaining + .checked_sub(quantity) + .map_err(|_| OperationError::RecoveryRequired)?; } Ok(losses) } @@ -202,7 +144,7 @@ pub(super) fn quantity(losses: &[Loss]) -> Result<StockTicks, OperationError> { clippy::too_many_arguments, reason = "exact original allocation and revision boundary" )] -async fn prior_quantity( +pub(super) async fn prior_quantity( connection: &mut SqliteConnection, input: &AttachmentInput, crypto: &WorkspaceCrypto, diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/inspection.rs b/crates/storage_sqlite/src/workspace/stock/inventory/inspection.rs @@ -0,0 +1,97 @@ +//! One currently authenticated pool snapshot, with no signer or store effect. +use super::*; +use radroots_domain::stock::{ObligationBacking, StockTicks}; +use radroots_storage::inventory::StockSnapshot; + +impl Turn<'_> { + pub async fn inspect( + &mut self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + id: PoolId, + proof: AttachmentProof, + ) -> Result<Option<StockSnapshot>, OperationError> { + let mut access = self.access(&binding, minimum, &proof).await?; + if access.authority.catalog != 19 { + return Err(OperationError::UnsupportedOperation); + } + access.record.require(StockAction::ReadPools, id)?; + access.record.require(StockAction::ReadOperations, id)?; + let retained = read_pool(self.connection, self.selected, self.crypto, id).await?; + access.projection_proof = Some( + authenticate_projection( + self.connection, + self.selected, + self.crypto, + &access.current, + &access.authority, + id, + retained.as_ref().map(|value| value.pool), + ) + .await?, + ); + let snapshot = if let Some(pool) = &retained { + let current = access + .authority + .inventory + .ok_or(OperationError::RecoveryRequired)?; + let before_revision = current + .revision + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?; + let mut cursor = super::allocations::InstalledCursor::new(id, before_revision)?; + let mut remaining = StockTicks::ZERO; + let mut backed = StockTicks::ZERO; + let mut deficit = StockTicks::ZERO; + while let Some(allocation) = + Box::pin(cursor.next(self.connection, self.selected, self.crypto)).await? + { + let value = allocation + .backing(self.connection, self.selected, self.crypto, before_revision) + .await?; + remaining = remaining + .checked_add(value.remaining()) + .map_err(|_| OperationError::RecoveryRequired)?; + backed = backed + .checked_add(value.backed()) + .map_err(|_| OperationError::RecoveryRequired)?; + deficit = deficit + .checked_add(value.deficit()) + .map_err(|_| OperationError::RecoveryRequired)?; + } + // Catalog19 has no quarantine/consumption/release producer. A + // current report must match its actual installed physical backing. + if backed != pool.pool.balances().physical().committed_hold + || pool.pool.balances().physical().physical_quarantine != StockTicks::ZERO + { + return Err(OperationError::RecoveryRequired); + } + let checkpoint = + radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( + self.selected.authority(), + current.revision, + current.head, + )? + .with_optional_authorization(access.authority.authorization); + Some(StockSnapshot::from_host_metadata( + pool.view.clone(), + ObligationBacking::new(remaining, backed, deficit) + .map_err(|_| OperationError::RecoveryRequired)?, + checkpoint, + )?) + } else { + None + }; + self.confirm( + &access, + &proof, + None, + retained.as_ref(), + None, + retained.is_none().then_some(id), + ) + .await?; + Ok(snapshot) + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/installation_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/installation_tests.rs @@ -88,6 +88,114 @@ async fn balances(r: &Rig, id: u8, available: u64, preparatory: u64, committed: ); } #[tokio::test] +async fn current_inspection_filters_original_allocations_and_requires_both_read_permissions() { + use radroots_storage::{ + inventory::InventoryStore, + workspace::seller_stock::{StockAction, StockResources}, + }; + let r = Rig::new().await; + let receipt = ready(&r).await; + retain(&r, &receipt, peer(&r, &receipt)).await; + installed(install(&r, &receipt).await.unwrap()); + let before = inventory_minimum(&r).await; + for (id, remaining, available) in [(80, 1, 9), (81, 2, 8)] { + let view = r + .store + .inspect_stock( + r.binding.clone(), + before, + pool(id), + r.enrollment + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap(), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(view.checkpoint(), before); + assert_eq!(view.installed_obligations().remaining().get(), remaining); + assert_eq!(view.installed_obligations().backed().get(), remaining); + assert_eq!(view.installed_obligations().deficit().get(), 0); + assert_eq!( + view.pool().snapshot().balances().physical().available.get(), + available + ); + } + assert_eq!(inventory_minimum(&r).await, before); + for actions in [ + vec![StockAction::ReadPools], + vec![StockAction::ReadOperations], + vec![StockAction::ReadPools, StockAction::ReadOperations], + ] { + let allowed = actions.len() == 2; + let child = StockGrantEnrollment::prepare( + &SellerAuthoritySelection::from_attachment(r.enrollment.input()), + "inspection-reader".into(), + UnixSeconds::new(290).unwrap(), + StockGrantScope::new(StockResources::pools(vec![pool(80)]).unwrap(), actions).unwrap(), + ) + .unwrap(); + r.store + .enroll_stock_grant( + r.binding.clone(), + inventory_minimum(&r).await, + r.enrollment.proof(), + &child, + ) + .await + .unwrap(); + let binding = r + .store + .authenticate(child.input().clone(), child.proof()) + .await + .unwrap(); + let minimum = inventory_minimum(&r).await; + let result = r + .store + .inspect_stock( + binding.clone(), + minimum, + pool(80), + child + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap(), + ) + .await; + if allowed { + assert_eq!( + result + .unwrap() + .unwrap() + .installed_obligations() + .remaining() + .get(), + 1 + ); + } else { + assert_eq!(result.unwrap_err(), OperationError::Unauthorized); + } + assert_eq!( + r.store + .inspect_stock( + binding, + minimum, + pool(81), + child + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap() + ) + .await + .unwrap_err(), + OperationError::Unauthorized + ); + } + r.store.close().await.unwrap(); +} + +#[tokio::test] async fn peer_only_t2_installs_original_agreement_and_two_work_items_once_across_reopen() { let mut r = Rig::new().await; let receipt = ready(&r).await; diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/rewrap_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/rewrap_tests.rs @@ -34,7 +34,7 @@ async fn additional( proof(r), ) .await; - let admission = if r.catalog == 18 { + let admission = if matches!(r.catalog, 18 | 19) { let StockRewrapOutcome::Claimed(admission) = admitted.unwrap() else { panic!("fresh confirmed admission required before wrapping") }; diff --git a/crates/storage_sqlite/src/workspace/stock/tests.rs b/crates/storage_sqlite/src/workspace/stock/tests.rs @@ -483,6 +483,19 @@ async fn retained_inventory_catalog(catalog: i64) { matches!(catalog, 8..=18) ); let minimum = authority.inventory_checkpoint().unwrap(); + assert_eq!( + store + .inspect_stock( + binding.clone(), + minimum, + PoolId::from_bytes([8; 32]), + proof + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap() + ) + .await, + Err(OperationError::UnsupportedOperation) + ); let context = CommandContextData::new( OperationId::from_bytes([7; 32]), binding.actor(), diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -292,6 +292,13 @@ enum Job { AttachmentProof, Reply<Option<radroots_storage::inventory::InventoryReceipt>, OperationError>, ), + InspectStock( + Box<WorkspaceBinding>, + radroots_storage::inventory::InventoryCheckpointRef, + radroots_domain::PoolId, + AttachmentProof, + Reply<Option<radroots_storage::inventory::StockSnapshot>, OperationError>, + ), Pool( Box<WorkspaceBinding>, radroots_storage::inventory::InventoryCheckpointRef, @@ -527,6 +534,9 @@ impl Job { Self::InventoryOperation(_, _, _, _, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } + Self::InspectStock(_, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } Self::Pool(_, _, _, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } @@ -730,6 +740,7 @@ impl Handle { | Job::ChangeStockGrant(..) | Job::ExecuteInventory(..) | Job::InventoryOperation(..) + | Job::InspectStock(..) | Job::Pool(..) | Job::OptionMapping(..) | Job::RetainStockSource(..) @@ -1556,6 +1567,23 @@ impl Handle { ))?; result.await.map_err(|_| OperationError::RecoveryRequired)? } + pub(super) async fn inspect_stock( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::inventory::InventoryCheckpointRef, + id: radroots_domain::PoolId, + proof: AttachmentProof, + ) -> Result<Option<radroots_storage::inventory::StockSnapshot>, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::InspectStock( + Box::new(binding), + minimum, + id, + proof, + reply, + ))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } pub(super) async fn pool( &self, binding: WorkspaceBinding, @@ -1599,6 +1627,7 @@ impl Handle { // allocations and protected deficit history before its SQL fence. Job::ExecuteInventory(..) | Job::InventoryOperation(..) + | Job::InspectStock(..) | Job::Pool(..) | Job::OptionMapping(..) => 1024 * 1024, Job::IssueStockConsent(..) | Job::PrepareStockAcceptance(..) => 512 * 1024, diff --git a/crates/storage_sqlite/src/workspace/worker/dispatch.rs b/crates/storage_sqlite/src/workspace/worker/dispatch.rs @@ -822,6 +822,23 @@ pub(super) fn run<'a>( }; let _ = reply.send(result); }), + Job::InspectStock(binding, minimum, id, proof, reply) => Box::pin(async move { + let result = if kind == Kind::SellerStock { + stock::inventory::Turn { + connection, + namespace, + selected: input, + crypto, + clock, + uncertain, + } + .inspect(*binding, minimum, id, proof) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + }), Job::Pool(binding, minimum, id, proof, reply) => Box::pin(async move { let result = if kind == Kind::SellerStock { stock::inventory::Turn { diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -43,6 +43,7 @@ struct Policy { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct StockAccounting { + native_inspection: NativeInspection, value_owner: String, scope: String, obligation_equation: String, @@ -72,6 +73,22 @@ struct NativeCorrection { #[derive(Deserialize)] #[serde(deny_unknown_fields)] +struct NativeInspection { + model_owner: String, + facade_method: String, + storage_port: String, + supported_catalogs: Vec<u8>, + worker_charge_bytes: u32, + same_checkpoint_required: bool, + original_allocation_required: bool, + read_pools_and_operations_required: bool, + pending_claims_are_installed: bool, + query_creates_store_effects: bool, + reports_global_business_completeness: bool, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] struct Toolchain { edition: String, stable: String, @@ -673,6 +690,9 @@ struct OrdinaryInventoryOwner { selected_workspace_views_share_owner: bool, exact_owned_attachment_required: bool, bounded_task_host_required: bool, + native_accepted_work_max: usize, + native_pending_work_blocks_queries: bool, + native_controls_drain_prior_work: bool, observer_loss_cancels_accepted_work: bool, close_drains_before_workspace_disposal: bool, stock_signer_or_transport_constructed: bool, @@ -744,6 +764,21 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { let p: Policy = serde_json::from_slice(raw) .map_err(|_| "shared SDK contract: invalid closed JSON shape".to_owned())?; let accounting = &p.stock_accounting; + let inspection = &accounting.native_inspection; + require( + inspection.model_owner == "radroots_storage.inventory.StockSnapshot" + && inspection.facade_method == "Stock.inspect" + && inspection.storage_port == "InventoryStore.inspect_stock" + && inspection.supported_catalogs == [19] + && inspection.worker_charge_bytes == 1048576 + && inspection.same_checkpoint_required + && inspection.original_allocation_required + && inspection.read_pools_and_operations_required + && !inspection.pending_claims_are_installed + && !inspection.query_creates_store_effects + && !inspection.reports_global_business_completeness, + "current stock inspection scope, permission, checkpoint or effect policy drift", + )?; let correction = &accounting.native_correction; require( correction.catalog == 19 @@ -1739,6 +1774,11 @@ fn validate_execution(e: &Execution, p: &Protocol, c: &Cutover) -> Result<(), St .selected_workspace_views_share_owner && e.ordinary_inventory_owner.exact_owned_attachment_required && e.ordinary_inventory_owner.bounded_task_host_required + && e.ordinary_inventory_owner.native_accepted_work_max == 32 + && !e + .ordinary_inventory_owner + .native_pending_work_blocks_queries + && e.ordinary_inventory_owner.native_controls_drain_prior_work && !e .ordinary_inventory_owner .observer_loss_cancels_accepted_work @@ -1855,6 +1895,28 @@ mod tests { } #[test] + fn current_inspection_cannot_invent_backing_authority_or_business_completeness() { + for (field, value) in [ + ("supported_catalogs", json!([18, 19])), + ("worker_charge_bytes", json!(16384)), + ("same_checkpoint_required", json!(false)), + ("original_allocation_required", json!(false)), + ("read_pools_and_operations_required", json!(false)), + ("pending_claims_are_installed", json!(true)), + ("query_creates_store_effects", json!(true)), + ("reports_global_business_completeness", json!(true)), + ] { + assert!( + validate_bytes(&changed( + &format!("/stock_accounting/native_inspection/{field}"), + value + )) + .is_err() + ); + } + } + + #[test] fn shared_consumers_cannot_silently_lose_buyer_or_seller_roles() { for host in ["cli", "browser", "generic_ffi"] { assert!( @@ -2188,6 +2250,9 @@ mod tests { ("selected_workspace_views_share_owner", json!(false)), ("exact_owned_attachment_required", json!(false)), ("bounded_task_host_required", json!(false)), + ("native_accepted_work_max", json!(33)), + ("native_pending_work_blocks_queries", json!(true)), + ("native_controls_drain_prior_work", json!(false)), ("observer_loss_cancels_accepted_work", json!(true)), ("close_drains_before_workspace_disposal", json!(false)), ("stock_signer_or_transport_constructed", json!(true)),