lib

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

commit 280dbf50915dffe469487eb303d635369f3bc6b0
parent f8fae3a381fa2bb3eab5f9bb4adb0e3eaa22281b
Author: triesap <tyson@radroots.org>
Date:   Thu, 29 Oct 2026 20:33:06 +0000

execution: resume explicitly rewrapped stock acceptances

- Own admitted rewraps and obtained outers through the existing client lifecycle.
- Expose explicit wrapping, exact-byte recovery and independently observed status.
- Separate envelope dispatch counts from cumulative delivery quotas.
- Verify native and Linux recovery, real relay retries, portable types and generated APIs.

Diffstat:
Mcontracts/api_baselines/radroots.txt | 4++++
Mcontracts/api_baselines/radroots_execution.txt | 12++++++++++++
Mcontracts/api_baselines/radroots_storage.txt | 3++-
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 11++++++++++-
Mcrates/execution/src/session/client.rs | 4++++
Mcrates/execution/src/session/client_commerce.rs | 146++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------
Acrates/execution/src/session/client_rewrap.rs | 150+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/execution/src/session/command.rs | 1+
Mcrates/execution/src/session/commerce.rs | 36++++++++++++++++++++++++++++++++++++
Mcrates/execution/src/session/commerce_delivery.rs | 153+++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------
Acrates/execution/src/session/commerce_rewrap.rs | 250+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/execution/src/session/commerce_run.rs | 3+++
Mcrates/execution/src/session/stock_delivery.rs | 26++++++++++++++++++++++----
Mcrates/execution/src/session/stock_evidence.rs | 9+++++++++
Acrates/execution/src/session/stock_rewrap.rs | 103+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/radroots/src/native_commerce_tests.rs | 2++
Acrates/radroots/src/native_stock_rewrap_tests.rs | 564+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/radroots/src/orders.rs | 73++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mcrates/storage/src/inventory/delivery_state.rs | 16++++++++++++++++
Mcrates/storage/tests/workspace/inventory_delivery.rs | 70++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/delivery/graph.rs | 15+++++++++++++--
Mcrates/storage_sqlite/src/workspace/stock/public_source/rewrap_tests.rs | 4++++
Mtools/xtask/src/architecture/decision_package.rs | 26++++++++++++++++++++++++++
23 files changed, 1569 insertions(+), 112 deletions(-)

diff --git a/contracts/api_baselines/radroots.txt b/contracts/api_baselines/radroots.txt @@ -158,14 +158,18 @@ pub async fn radroots::operations::Operations<'a>::resume(&self, radroots_domain pub mod radroots::orders pub use radroots::orders::AcceptOrderInput pub use radroots::orders::AcceptanceRecipient +pub use radroots::orders::AcceptanceRewrapStatus pub use radroots::orders::AcceptanceStatus pub use radroots::orders::AcceptanceUnissuedReceipt pub use radroots::orders::InstalledAcceptance pub struct radroots::orders::Orders<'a> impl<'a> radroots::orders::Orders<'a> pub async fn radroots::orders::Orders<'a>::accept(&self, 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::ExecutionResult<radroots_execution::session::commerce::AcceptanceStatus> +pub async fn radroots::orders::Orders<'a>::acceptance_rewrap_status(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_domain::identifier::OperationId) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceRewrapStatus> pub async fn radroots::orders::Orders<'a>::acceptance_status(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> pub async fn radroots::orders::Orders<'a>::resume_acceptance(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::ExecutionResult<radroots_execution::session::commerce::AcceptanceStatus> +pub async fn radroots::orders::Orders<'a>::resume_acceptance_rewrap(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_domain::identifier::OperationId) -> radroots_execution::ExecutionResult<radroots_execution::session::commerce::AcceptanceRewrapStatus> +pub async fn radroots::orders::Orders<'a>::rewrap_acceptance(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_domain::identifier::OperationId) -> radroots_execution::ExecutionResult<radroots_execution::session::commerce::AcceptanceRewrapStatus> pub mod radroots::signing pub use radroots::signing::ArtifactFingerprint pub use radroots::signing::ArtifactRole diff --git a/contracts/api_baselines/radroots_execution.txt b/contracts/api_baselines/radroots_execution.txt @@ -50,6 +50,14 @@ pub radroots_execution::session::commerce::AcceptanceRecipient::claim: core::opt pub radroots_execution::session::commerce::AcceptanceRecipient::evidence: core::option::Option<radroots_storage::inventory::evidence::StockEvidenceReceipt> pub radroots_execution::session::commerce::AcceptanceRecipient::original_unissued: core::option::Option<radroots_execution::session::commerce::AcceptanceUnissuedReceipt> pub radroots_execution::session::commerce::AcceptanceRecipient::recipient: radroots_identity::key::PublicKey +pub struct radroots_execution::session::commerce::AcceptanceRewrapStatus +impl radroots_execution::session::commerce::AcceptanceRewrapStatus +pub const fn radroots_execution::session::commerce::AcceptanceRewrapStatus::delivery(&self) -> core::option::Option<&radroots_storage::inventory::delivery_state::StockDeliverySummary> +pub const fn radroots_execution::session::commerce::AcceptanceRewrapStatus::recipient(&self) -> radroots_identity::key::PublicKey +pub const fn radroots_execution::session::commerce::AcceptanceRewrapStatus::rewrap_id(&self) -> radroots_domain::identifier::OperationId +pub const fn radroots_execution::session::commerce::AcceptanceRewrapStatus::state(&self) -> core::option::Option<radroots_storage::inventory::rewrap::StockRewrapState> +impl core::fmt::Debug for radroots_execution::session::commerce::AcceptanceRewrapStatus +pub fn radroots_execution::session::commerce::AcceptanceRewrapStatus::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_execution::session::commerce::AcceptanceSelection pub radroots_execution::session::commerce::AcceptanceSelection::binding: radroots_storage::workspace::WorkspaceBinding pub radroots_execution::session::commerce::AcceptanceSelection::digest: radroots_domain::identifier::CommandDigest @@ -136,6 +144,10 @@ impl<H: radroots_execution::session::SessionHost + 'static> radroots_execution:: pub async fn radroots_execution::session::ClientSession<H>::inquire(&self, alloc::sync::Arc<dyn radroots_storage::command::OperationJournal>, radroots_execution::workspace::CommandContext, radroots_protocol::command::InquireInput) -> radroots_execution::ExecutionResult<radroots_execution::OperationReceipt<radroots_domain::message::ChatMessage>> pub async fn radroots_execution::session::ClientSession<H>::publish_listing(&self, alloc::sync::Arc<dyn radroots_storage::command::OperationJournal>, radroots_execution::workspace::CommandContext, radroots_protocol::listing::PublishInput) -> radroots_execution::ExecutionResult<radroots_execution::OperationReceipt<radroots_domain::listing::view::Listing>> pub async fn radroots_execution::session::ClientSession<H>::resume_command(&self, alloc::sync::Arc<dyn radroots_storage::command::OperationJournal>, &radroots_execution::workspace::WorkspaceSession, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>) -> radroots_execution::ExecutionResult<radroots_execution::OperationStatus> +impl<H: radroots_execution::session::SessionHost + 'static> radroots_execution::session::ClientSession<H> +pub async fn radroots_execution::session::ClientSession<H>::resume_stock_rewrap(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, alloc::sync::Arc<dyn radroots_execution::session::commerce::AcceptanceStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_domain::identifier::OperationId) -> radroots_execution::ExecutionResult<radroots_execution::session::commerce::AcceptanceRewrapStatus> +pub async fn radroots_execution::session::ClientSession<H>::rewrap_stock_acceptance(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, alloc::sync::Arc<dyn radroots_execution::session::commerce::AcceptanceStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_domain::identifier::OperationId) -> radroots_execution::ExecutionResult<radroots_execution::session::commerce::AcceptanceRewrapStatus> +pub async fn radroots_execution::session::ClientSession<H>::stock_acceptance_rewrap_status(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_domain::identifier::OperationId) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceRewrapStatus> impl<H: radroots_execution::session::SessionHost> radroots_execution::session::ClientSession<H> pub async fn radroots_execution::session::ClientSession<H>::attach_signer(&self, radroots_signing::provider::SignerHandle) -> radroots_execution::Result<radroots_execution::session::SignerSession> pub async fn radroots_execution::session::ClientSession<H>::attach_workspace(&self, alloc::sync::Arc<dyn radroots_storage::workspace::WorkspaceStore>, radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof) -> radroots_execution::Result<radroots_execution::workspace::WorkspaceSession> diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -1553,9 +1553,10 @@ pub fn radroots_storage::inventory::StockDeliverySummary::acceptance_satisfied(& pub const fn radroots_storage::inventory::StockDeliverySummary::attempt_count(&self) -> u16 pub const fn radroots_storage::inventory::StockDeliverySummary::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef pub fn radroots_storage::inventory::StockDeliverySummary::from_store_report(&radroots_storage::inventory::StockEnvelopeRequest, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>, core::option::Option<radroots_storage::command::DeliveryIntent>, u16, alloc::vec::Vec<radroots_storage::inventory::StockDeliveryTargetProgress>, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> -pub fn radroots_storage::inventory::StockDeliverySummary::from_store_report_with_policy_source(&radroots_storage::inventory::StockEnvelopeRequest, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>, core::option::Option<radroots_storage::command::DeliveryIntent>, u16, alloc::vec::Vec<radroots_storage::inventory::StockDeliveryTargetProgress>, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::inventory::StockDeliverySummary::from_store_report_with_policy_source(&radroots_storage::inventory::StockEnvelopeRequest, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>, core::option::Option<radroots_storage::command::DeliveryIntent>, u16, u16, alloc::vec::Vec<radroots_storage::inventory::StockDeliveryTargetProgress>, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> pub const fn radroots_storage::inventory::StockDeliverySummary::original_intent(&self) -> core::option::Option<&radroots_storage::command::DeliveryIntent> pub const fn radroots_storage::inventory::StockDeliverySummary::publication_policy_source(&self) -> core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt> +pub const fn radroots_storage::inventory::StockDeliverySummary::selected_attempt_count(&self) -> u16 pub const fn radroots_storage::inventory::StockDeliverySummary::source(&self) -> core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt> pub fn radroots_storage::inventory::StockDeliverySummary::targets(&self) -> &[radroots_storage::inventory::StockDeliveryTargetProgress] impl core::fmt::Debug for radroots_storage::inventory::StockDeliverySummary diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -512,6 +512,7 @@ "first_complete_targets_and_criterion_immutable": true, "ordinary_command_replays_existing_attempt": false, "ordinary_fresh_claim_binds_observed_attempt_count": true, + "ordinary_repeat_uses_selected_envelope_attempt_count": true, "ordinary_obtained_material_owner": "ClientSession.stock_captures", "ordinary_peer_delivery_precedes_self_signing": true, "installed_original_delivery_requires_signer": false, @@ -586,7 +587,15 @@ "existing_or_uncertain_admission_grants_invocation": false, "unknown_admissions_count_toward_limit": true, "descriptor_includes_uncaptured_admissions": true, - "admission_repair_grants_history_or_invocation": false + "admission_repair_grants_history_or_invocation": false, + "ordinary_owner": "ClientSession.stock_captures", + "ordinary_facade_methods": [ + "Orders.rewrap_acceptance", + "Orders.resume_acceptance_rewrap", + "Orders.acceptance_rewrap_status" + ], + "ordinary_resume_generates_key_or_business_signature": false, + "ordinary_status_is_atomic_absence_proof": false } }, "provenance": { diff --git a/crates/execution/src/session/client.rs b/crates/execution/src/session/client.rs @@ -18,6 +18,10 @@ mod inventory; #[path = "client_commerce.rs"] mod commerce; +#[cfg(feature = "workspace_session")] +#[path = "client_rewrap.rs"] +mod rewrap; + struct Resources<H> { host: H, signer: Shared<Mutex<Option<SignerSession>>>, diff --git a/crates/execution/src/session/client_commerce.rs b/crates/execution/src/session/client_commerce.rs @@ -153,7 +153,88 @@ impl<H: SessionHost + 'static> ClientSession<H> { >, ) -> crate::ExecutionResult<AcceptanceStatus> { let proposed = OperationContext::proposed(Some(operation)); - if matches!(&mode, RunMode::Command) { + self.submit_stock_commerce( + scope, + operation, + mode, + capture, + move |(selection, request): (AcceptanceSelection, Option<StockAcceptanceRequest>), + proof, + runtime, + resources| { + Box::pin(async move { + if let Some(request) = request { + let credential = proof + .with_secret(|bytes| { + radroots_storage::workspace::AttachmentProof::from_protected_input( + bytes, + ) + }) + .map_err(|e| Error::operation(e.into(), proposed))?; + match inventory + .prepare_stock_acceptance(request, credential) + .await + .map_err(|e| Error::operation(e, proposed))? + { + StockAcceptanceOutcome::Unknown(_) => { + return Err(Error::admission_uncertain(operation).into()); + } + StockAcceptanceOutcome::Prepared(value) + if value.attempt().workspace_id() + == selection.binding.input().workspace_id() + && value.attempt().operation_id() == operation + && value.attempt().command_digest() == selection.digest + && value.attempt().transaction_id().is_some() => {} + StockAcceptanceOutcome::Aborted(value) + if value.attempt().workspace_id() + == selection.binding.input().workspace_id() + && value.attempt().operation_id() == operation + && value.attempt().command_digest() == selection.digest + && value.attempt().transaction_id().is_some() => {} + _ => { + return Err(Error::operation( + OperationError::RecoveryRequired, + OperationContext::admission_unknown(operation), + ) + .into()); + } + } + } + if let Some(runtime) = runtime { + runtime + .run_acceptance(store, inventory, selection, &proof, resources, mode) + .await + } else { + let retained = OperationContext::retained(operation); + let view = store + .snapshot(selection.clone(), &proof) + .await + .map_err(|e| Error::operation(e, retained))?; + crate::session::commerce::observe(&selection, view.as_ref()) + .map_err(|e| Error::operation(e, retained).into()) + } + }) + }, + ) + .await + } + /// One owned lifecycle path for initial acceptance and explicit rewrapping. + /// Caller observation never owns the admitted task or obtained materials. + pub(super) async fn submit_stock_commerce<P: HostBound + 'static, T: HostBound + 'static>( + &self, + scope: &WorkspaceSession, + operation: OperationId, + mode: RunMode, + prepare: impl FnOnce(WorkspaceBinding) -> Result<P, OperationError>, + work: impl FnOnce( + P, + radroots_storage::workspace::AttachmentProof, + Option<Shared<crate::session::command::CommandRuntime>>, + SigningResources, + ) -> crate::session::HostFuture<'static, crate::ExecutionResult<T>>, + ) -> crate::ExecutionResult<T> { + let proposed = OperationContext::proposed(Some(operation)); + if matches!(mode, RunMode::Command) { self.stock_captures .ensure_ready() .map_err(|e| Error::operation(e, proposed))?; @@ -179,74 +260,25 @@ impl<H: SessionHost + 'static> ClientSession<H> { let (binding, proof) = scope .captured_input() .map_err(|e| Error::operation(e.into(), proposed))?; - let (selection, request) = capture(binding).map_err(|e| Error::operation(e, proposed))?; - let runtime = self.commands.clone(); + let input = prepare(binding).map_err(|e| Error::operation(e, proposed))?; let resources = SigningResources { signer: self.signer_session(), lease: Shared::new((permit, budget)) as Shared<dyn HostBound>, stock_captures: self.stock_captures.clone(), }; + let captures = self.stock_captures.clone(); + let future = work(input, proof, self.commands.clone(), resources); let (reply, observed) = futures::channel::oneshot::channel(); host.submit(Box::pin(async move { let result = async { - if matches!(&mode, RunMode::Resume) { - resources.stock_captures.drain().await?; + if matches!(mode, RunMode::Resume) { + captures.drain().await?; } else { - resources - .stock_captures + captures .ensure_ready() .map_err(|e| Error::operation(e, proposed))?; } - if let Some(request) = request { - let credential = proof - .with_secret(|bytes| { - radroots_storage::workspace::AttachmentProof::from_protected_input( - bytes, - ) - }) - .map_err(|e| Error::operation(e.into(), proposed))?; - match inventory - .prepare_stock_acceptance(request, credential) - .await - .map_err(|e| Error::operation(e, proposed))? - { - StockAcceptanceOutcome::Unknown(_) => { - return Err(Error::admission_uncertain(operation).into()); - } - StockAcceptanceOutcome::Prepared(value) - if value.attempt().workspace_id() - == selection.binding.input().workspace_id() - && value.attempt().operation_id() == operation - && value.attempt().command_digest() == selection.digest - && value.attempt().transaction_id().is_some() => {} - StockAcceptanceOutcome::Aborted(value) - if value.attempt().workspace_id() - == selection.binding.input().workspace_id() - && value.attempt().operation_id() == operation - && value.attempt().command_digest() == selection.digest - && value.attempt().transaction_id().is_some() => {} - _ => { - return Err(Error::operation( - OperationError::RecoveryRequired, - OperationContext::admission_unknown(operation), - ) - .into()); - } - } - } - if let Some(runtime) = runtime { - runtime - .run_acceptance(store, inventory, selection, &proof, resources, mode) - .await - } else { - let retained = OperationContext::retained(operation); - let view = store - .snapshot(selection.clone(), &proof) - .await - .map_err(|e| Error::operation(e, retained))?; - crate::session::commerce::observe(&selection, view.as_ref()) - .map_err(|e| Error::operation(e, retained).into()) - } + future.await } .await; let _ = reply.send(result); diff --git a/crates/execution/src/session/client_rewrap.rs b/crates/execution/src/session/client_rewrap.rs @@ -0,0 +1,150 @@ +//! Client-owned explicit carrier work reuses commerce admission and shutdown. +use super::{ClientSession, SessionHost, Shared}; +use crate::{ + Error, OperationContext, + session::{command::RunMode, commerce::*}, + workspace::WorkspaceSession, +}; +use alloc::boxed::Box; +use radroots_domain::{CommandDigest, OperationId, PublicKey}; +use radroots_storage::{ + command::OperationError, + inventory::{InventoryCheckpointRef, InventoryStore}, +}; + +impl<H: SessionHost + 'static> ClientSession<H> { + /// Requests one explicit additional outer for an actual original F10/S/T2. + /// Only a newly confirmed admission can create its key. Repeating the same + /// identity observes/resumes known bytes and never regenerates an unknown. + #[allow(clippy::too_many_arguments)] + pub async fn rewrap_stock_acceptance( + &self, + inventory: Shared<dyn InventoryStore>, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: PublicKey, + id: OperationId, + ) -> crate::ExecutionResult<AcceptanceRewrapStatus> { + self.submit_rewrap( + inventory, + store, + scope, + minimum, + operation, + digest, + recipient, + id, + RunMode::Command, + ) + .await + } + /// Resumes a known exact outer using current scoped consent. No wrapping + /// admission, temporary key or business signature is created by recovery. + #[allow(clippy::too_many_arguments)] + pub async fn resume_stock_rewrap( + &self, + inventory: Shared<dyn InventoryStore>, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: PublicKey, + id: OperationId, + ) -> crate::ExecutionResult<AcceptanceRewrapStatus> { + self.submit_rewrap( + inventory, + store, + scope, + minimum, + operation, + digest, + recipient, + id, + RunMode::Resume, + ) + .await + } + #[allow(clippy::too_many_arguments)] + async fn submit_rewrap( + &self, + inventory: Shared<dyn InventoryStore>, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: PublicKey, + id: OperationId, + mode: RunMode, + ) -> crate::ExecutionResult<AcceptanceRewrapStatus> { + self.submit_stock_commerce( + scope, + operation, + mode, + move |binding| { + Ok(AcceptanceSelection { + binding, + minimum, + operation, + digest, + }) + }, + move |selection, proof, runtime, resources| { + Box::pin(async move { + let runtime = runtime.ok_or_else(|| { + Error::operation( + OperationError::UnsupportedOperation, + OperationContext::retained(operation), + ) + })?; + runtime + .run_stock_rewrap( + store, inventory, selection, &proof, resources, recipient, id, mode, + ) + .await + }) + }, + ) + .await + } + /// Reads independent admission/capture/delivery facts with current access. + /// An absent capture grants neither a fresh wrapping nor dispatch right. + #[allow(clippy::too_many_arguments)] + pub async fn stock_acceptance_rewrap_status( + &self, + inventory: Shared<dyn InventoryStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: PublicKey, + id: OperationId, + ) -> crate::Result<AcceptanceRewrapStatus> { + self.run_stock( + scope, + OperationContext::retained(operation), + move |binding, proof| { + Box::pin(async move { + rewrap_status( + &inventory, + &AcceptanceSelection { + binding, + minimum, + operation, + digest, + }, + recipient, + id, + &proof, + ) + .await + }) + }, + ) + .await + } +} diff --git a/crates/execution/src/session/command.rs b/crates/execution/src/session/command.rs @@ -105,6 +105,7 @@ pub(super) struct SigningResources { pub(super) lease: Shared<dyn HostBound>, pub(super) stock_captures: Shared<super::stock_evidence::Owner>, } +#[derive(Clone, Copy)] pub(super) enum RunMode { Command, Resume, diff --git a/crates/execution/src/session/commerce.rs b/crates/execution/src/session/commerce.rs @@ -23,6 +23,7 @@ use radroots_storage::{ #[path = "commerce_run.rs"] mod run; pub(crate) use run::observe; +pub(in crate::session) use run::rewrap_status; /// Original operation selectors and independently retained minimum; no authority. #[derive(Clone)] @@ -241,3 +242,38 @@ impl fmt::Debug for AcceptanceStatus { f.write_str("AcceptanceStatus(<redacted>)") } } + +/// Separate current-access observations of one explicitly requested rewrap. +/// A missing outer is an unknown wrapping outcome, never proof of nonissuance +/// or permission to regenerate. Delivery carries its own authenticated read +/// checkpoint; this report does not claim an atomic combined absence snapshot. +#[derive(Clone)] +pub struct AcceptanceRewrapStatus { + id: OperationId, + recipient: PublicKey, + state: Option<radroots_storage::inventory::StockRewrapState>, + delivery: Option<StockDeliverySummary>, +} +impl AcceptanceRewrapStatus { + /// Explicit request identity, distinct from the original business command. + pub const fn rewrap_id(&self) -> OperationId { + self.id + } + /// Recipient whose original evidence and additional outer were selected. + pub const fn recipient(&self) -> PublicKey { + self.recipient + } + /// Observed admission and optional captured outer; absence grants no work. + pub const fn state(&self) -> Option<radroots_storage::inventory::StockRewrapState> { + self.state + } + /// Independent current delivery observation for the exact captured outer. + pub const fn delivery(&self) -> Option<&StockDeliverySummary> { + self.delivery.as_ref() + } +} +impl fmt::Debug for AcceptanceRewrapStatus { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("AcceptanceRewrapStatus(<redacted>)") + } +} diff --git a/crates/execution/src/session/commerce_delivery.rs b/crates/execution/src/session/commerce_delivery.rs @@ -59,7 +59,7 @@ impl CommandRuntime { .and_then(|values| values.get(index)) .ok_or_else(|| fail(OperationError::UnsupportedOperation))?; if state.acceptance_satisfied().map_err(fail)? - || (state.attempt_count() != 0 && matches!(mode, RunMode::Command)) + || (state.selected_attempt_count() != 0 && matches!(mode, RunMode::Command)) { return Ok(()); } @@ -67,41 +67,14 @@ impl CommandRuntime { .plan() .and_then(|plan| plan.routes().iter().find(|v| v.participant() == recipient)) .ok_or_else(|| fail(OperationError::RecoveryRequired))?; - let allowed = self.io.targets(route).map_err(fail)?; - let (targets, policy) = match state.original_intent() { - Some(original) => { - if original.targets().targets().iter().any(|target| { - !allowed - .targets() - .iter() - .any(|v| v.fingerprint() == target.fingerprint()) - }) { - return Err(fail(OperationError::UnverifiedApproval)); - } - (original.targets().clone(), original.policy().clone()) - } - None => (allowed, self.io.publication_policy()), - }; - let selected = targets - .targets() - .iter() - .filter(|target| { - !state.targets().iter().any(|v| { - v.target() == target.fingerprint() - && (v.accepted() || v.potential_attempts() >= 12) - }) - }) - .cloned() - .collect::<Vec<_>>(); - if selected.is_empty() { + let Some(plan) = self.stock_delivery_plan(state, route, mode).map_err(fail)? else { return Ok(()); - } - let selected = - TargetSet::new(selected).map_err(|_| fail(OperationError::RecoveryRequired))?; + }; let context = || -> Result<DeliveryContext, OperationError> { Ok(DeliveryContext { selection: selection.clone(), recipient, + rewrap: None, store: inventory.clone(), proof: copy(proof)?, _lease: resources.lease.clone(), @@ -136,6 +109,85 @@ impl CommandRuntime { resources.stock_captures.capture_envelope(&pending).await? } }; + self.send_stock_delivery( + &resources.stock_captures, + context().map_err(fail)?, + outer, + state, + plan, + None, + ) + .await + } + pub(super) fn stock_publication_policy( + &self, + route: &radroots_protocol::nip59::CapturedDmRoute, + original: Option<&DeliveryIntent>, + ) -> Result<(TargetSet, radroots_transport::policy::SatisfactionPolicy), OperationError> { + let allowed = self.io.targets(route)?; + if let Some(original) = original { + if original.targets().targets().iter().any(|target| { + !allowed + .targets() + .iter() + .any(|v| v.fingerprint() == target.fingerprint()) + }) { + return Err(OperationError::UnverifiedApproval); + } + Ok((original.targets().clone(), original.policy().clone())) + } else { + Ok((allowed, self.io.publication_policy())) + } + } + pub(super) fn stock_delivery_plan( + &self, + state: &radroots_storage::inventory::StockDeliverySummary, + route: &radroots_protocol::nip59::CapturedDmRoute, + mode: &RunMode, + ) -> Result<Option<StockDeliveryPlan>, OperationError> { + if state.acceptance_satisfied()? + || (state.selected_attempt_count() != 0 && matches!(mode, RunMode::Command)) + { + return Ok(None); + } + let (targets, policy) = self.stock_publication_policy(route, state.original_intent())?; + let selected = targets + .targets() + .iter() + .filter(|target| { + !state.targets().iter().any(|v| { + v.target() == target.fingerprint() + && (v.accepted() || v.potential_attempts() >= 12) + }) + }) + .cloned() + .collect::<Vec<_>>(); + if selected.is_empty() { + return Ok(None); + } + let selected = TargetSet::new(selected).map_err(|_| OperationError::RecoveryRequired)?; + Ok(Some(StockDeliveryPlan { + targets, + selected, + policy, + })) + } + /// One transport path for originals and explicitly selected retained outers. + pub(super) async fn send_stock_delivery( + &self, + owner: &crate::session::stock_evidence::Owner, + c: DeliveryContext, + outer: radroots_storage::inventory::StockEnvelopeReceipt, + state: &radroots_storage::inventory::StockDeliverySummary, + plan: StockDeliveryPlan, + selected_event: Option<radroots_domain::EnvelopeEventId>, + ) -> crate::ExecutionResult<()> { + let fail = |e| { + crate::ExecutionFailure::from(Error::operation( + e, + OperationContext::retained(c.selection.operation), + )) + }; let deadline = self .io .now() @@ -148,27 +200,32 @@ impl CommandRuntime { let intent = DeliveryIntent::new( &self.io.delivery_id().map_err(fail)?, outer.event_id(), - &targets, - &policy, + &plan.targets, + &plan.policy, deadline, ) - .and_then(|v| v.with_selection(&selected)) + .and_then(|v| v.with_selection(&plan.selected)) .map_err(fail)?; - let context = context().map_err(fail)?; // The original outer's capture checkpoint is historical metadata. Use // the authenticated current selection, including authorization state. let request = StockDeliveryRequest::new( - selection.binding.clone(), - selection.minimum, - selection.operation, - selection.digest, - recipient, + c.selection.binding.clone(), + c.selection.minimum, + c.selection.operation, + c.selection.digest, + c.recipient, intent.clone(), ) .and_then(|request| request.with_expected_attempt_count(state.attempt_count())) .map_err(fail)?; - let attempt = match inventory - .prepare_stock_delivery_attempt(request, copy(proof).map_err(fail)?) + let request = if let Some(event) = selected_event { + request.with_envelope(event).map_err(fail)? + } else { + request + }; + let attempt = match c + .store + .prepare_stock_delivery_attempt(request, copy(&c.proof).map_err(fail)?) .await .map_err(fail)? { @@ -194,10 +251,14 @@ impl CommandRuntime { .ok() .and_then(|v| v.get().checked_mul(1000)) .and_then(NonZeroU64::new); - let pending = resources - .stock_captures - .retain_delivery(context, attempt, result, observed); - resources.stock_captures.capture_delivery(&pending).await?; + let pending = owner.retain_delivery(c, attempt, result, observed); + owner.capture_delivery(&pending).await?; Ok(()) } } + +pub(super) struct StockDeliveryPlan { + targets: TargetSet, + selected: TargetSet, + policy: radroots_transport::policy::SatisfactionPolicy, +} diff --git a/crates/execution/src/session/commerce_rewrap.rs b/crates/execution/src/session/commerce_rewrap.rs @@ -0,0 +1,250 @@ +//! Explicit wrapping never renews original business signing or dispatch authority. +use super::*; +use crate::session::stock_evidence::DeliveryContext; +use radroots_storage::inventory::{StockEnvelopeRequest, StockRewrapOutcome, StockRewrapRequest}; + +fn request( + selection: &AcceptanceSelection, + recipient: PublicKey, +) -> Result<StockEnvelopeRequest, OperationError> { + StockEnvelopeRequest::new( + selection.binding.clone(), + selection.minimum, + selection.operation, + selection.digest, + recipient, + None, + ) +} +/// Separate authenticated observations, never a new wrapping or send permit. +pub(in crate::session) async fn status( + inventory: &Shared<dyn InventoryStore>, + selection: &AcceptanceSelection, + recipient: PublicKey, + id: OperationId, + proof: &AttachmentProof, +) -> Result<AcceptanceRewrapStatus, OperationError> { + let state = inventory + .stock_rewrap_attempt( + StockRewrapRequest::new(request(selection, recipient)?, id), + copy(proof)?, + ) + .await?; + if let Some(state) = &state { + let admission = state.admission(); + let original = admission.original(); + if admission.rewrap_id() != id + || !same(original.attempt(), selection) + || original.recipient() != recipient + || admission.checkpoint().authority() != selection.minimum.authority() + { + return Err(OperationError::RecoveryRequired); + } + } + let delivery = if let Some(outer) = state.as_ref().and_then(|state| state.envelope()) { + let summary = inventory + .stock_delivery_summary( + request(selection, recipient)?.with_envelope(outer.event_id()), + copy(proof)?, + ) + .await?; + if summary.source() != Some(outer) { + return Err(OperationError::RecoveryRequired); + } + Some(summary) + } else { + None + }; + Ok(AcceptanceRewrapStatus { + id, + recipient, + state, + delivery, + }) +} +impl CommandRuntime { + #[allow(clippy::too_many_arguments)] + pub(in crate::session) async fn run_stock_rewrap( + &self, + store: Shared<dyn AcceptanceStore>, + inventory: Shared<dyn InventoryStore>, + selection: AcceptanceSelection, + proof: &AttachmentProof, + resources: SigningResources, + recipient: PublicKey, + id: OperationId, + mode: RunMode, + ) -> crate::ExecutionResult<AcceptanceRewrapStatus> { + let fail = |e| { + crate::ExecutionFailure::from(Error::operation( + e, + OperationContext::retained(selection.operation), + )) + }; + if !self.io.enabled() { + return Err(fail(OperationError::UnsupportedOperation)); + } + let _creation = resources.stock_captures.delivery_serial.lock().await; + resources.stock_captures.ensure_ready().map_err(fail)?; + let snapshot = store + .snapshot(selection.clone(), proof) + .await + .map_err(fail)?; + observe(&selection, snapshot.as_ref()).map_err(fail)?; + let installed = snapshot + .installation() + .ok_or_else(|| fail(OperationError::MissingHistory))?; + if snapshot.aborted() { + return Err(fail(OperationError::InvalidCommand)); + } + let evidence = snapshot + .recipients() + .iter() + .find(|entry| entry.recipient == recipient) + .and_then(|entry| entry.evidence) + .ok_or_else(|| fail(OperationError::MissingHistory))?; + let mut current = selection.clone(); + current.minimum = snapshot.checkpoint(); + let original = inventory + .stock_envelope( + request(&current, recipient).map_err(fail)?, + copy(proof).map_err(fail)?, + ) + .await + .map_err(fail)? + .ok_or_else(|| fail(OperationError::MissingHistory))?; + let original = original.receipt(); + if original.rewrap_admission_transaction_id().is_some() + || original.evidence() != evidence + || original.installation_transaction_id() + != installed + .attempt + .transaction_id() + .ok_or_else(|| fail(OperationError::RecoveryRequired))? + { + return Err(fail(OperationError::RecoveryRequired)); + } + let route = snapshot + .plan() + .and_then(|plan| { + plan.routes() + .iter() + .find(|route| route.participant() == recipient) + }) + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + let mut view = status(&inventory, &current, recipient, id, proof) + .await + .map_err(fail)?; + if matches!(mode, RunMode::Command) && view.state.is_none() { + let index = snapshot + .recipients() + .iter() + .position(|entry| entry.recipient == recipient) + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + let prior = snapshot + .delivery() + .and_then(|values| values.get(index)) + .ok_or_else(|| fail(OperationError::UnsupportedOperation))?; + let (targets, _) = self + .stock_publication_policy(route, prior.original_intent()) + .map_err(fail)?; + if targets.targets().iter().all(|target| { + prior.targets().iter().any(|entry| { + entry.target() == target.fingerprint() && entry.potential_attempts() >= 12 + }) + }) { + return Err(fail(OperationError::DeliveryAttemptLimit)); + } + let source = store + .signing_evidence(current.clone(), evidence, proof) + .await + .map_err(fail)? + .ok_or_else(|| fail(OperationError::MissingHistory))?; + if source.receipt() != evidence { + return Err(fail(OperationError::RecoveryRequired)); + } + let context = DeliveryContext { + selection: current.clone(), + recipient, + store: inventory.clone(), + proof: copy(proof).map_err(fail)?, + _lease: resources.lease.clone(), + rewrap: None, + }; + let pending = resources + .stock_captures + .retain_rewrap_admission(context, original, id); + match resources.stock_captures.prepare_rewrap(&pending).await? { + StockRewrapOutcome::Claimed(admitted) => { + // Prepare original credentials before local key generation. + let context = DeliveryContext { + selection: current.clone(), + recipient, + store: inventory.clone(), + proof: copy(proof).map_err(fail)?, + _lease: resources.lease.clone(), + rewrap: Some(*admitted), + }; + let now = self.io.now().map_err(fail)?; + if now < admitted.prepared_at() || now >= admitted.expires_at() { + return Err(fail(OperationError::DeadlineExceeded)); + } + let candidate = source + .with_json(|raw| self.io.private_envelope(recipient, raw)) + .map_err(fail)?; + let observed = self + .io + .now() + .ok() + .and_then(|v| v.get().checked_mul(1000)) + .and_then(NonZeroU64::new); + let pending = resources + .stock_captures + .retain_envelope(context, candidate, observed); + resources.stock_captures.capture_envelope(&pending).await?; + } + StockRewrapOutcome::Retained(_) => {} + StockRewrapOutcome::Unknown(_) => { + return Err(fail(OperationError::RecoveryRequired)); + } + } + view = status(&inventory, &current, recipient, id, proof) + .await + .map_err(fail)?; + } + // Existing/uncaptured admissions remain unknown. Resume never generates + // keys or another inner signature, even after restart or a lost waiter. + if let Some(outer) = view.state.as_ref().and_then(|state| state.envelope()) { + let summary = view + .delivery + .as_ref() + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + if let Some(plan) = self + .stock_delivery_plan(summary, route, &mode) + .map_err(fail)? + { + let context = DeliveryContext { + selection: current.clone(), + recipient, + store: inventory.clone(), + proof: copy(proof).map_err(fail)?, + _lease: resources.lease.clone(), + rewrap: None, + }; + self.send_stock_delivery( + &resources.stock_captures, + context, + outer, + summary, + plan, + Some(outer.event_id()), + ) + .await?; + view = status(&inventory, &current, recipient, id, proof) + .await + .map_err(fail)?; + } + } + Ok(view) + } +} diff --git a/crates/execution/src/session/commerce_run.rs b/crates/execution/src/session/commerce_run.rs @@ -22,6 +22,9 @@ use radroots_signing::{ use radroots_storage::inventory::{InventoryStore, StockEvidenceOutcome}; #[path = "commerce_delivery.rs"] mod delivery; +#[path = "commerce_rewrap.rs"] +mod rewrap; +pub(in crate::session) use rewrap::status as rewrap_status; fn same(attempt: CommitAttempt, selection: &AcceptanceSelection) -> bool { attempt.workspace_id() == selection.binding.input().workspace_id() diff --git a/crates/execution/src/session/stock_delivery.rs b/crates/execution/src/session/stock_delivery.rs @@ -13,12 +13,13 @@ pub(in crate::session) struct DeliveryContext { pub store: Shared<dyn InventoryStore>, pub proof: AttachmentProof, pub _lease: Shared<dyn HostBound>, + pub rewrap: Option<StockRewrapAdmission>, } impl DeliveryContext { - fn error(&self, reason: OperationError) -> Error { + pub(super) fn error(&self, reason: OperationError) -> Error { Error::capture_pending(reason, OperationContext::retained(self.selection.operation)) } - fn request( + pub(super) fn request( &self, observed: Option<NonZeroU64>, ) -> Result<StockEnvelopeRequest, OperationError> { @@ -31,7 +32,7 @@ impl DeliveryContext { observed, ) } - fn proof(&self) -> Result<AttachmentProof, OperationError> { + pub(super) fn proof(&self) -> Result<AttachmentProof, OperationError> { self.proof .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) .map_err(Into::into) @@ -91,7 +92,21 @@ impl Owner { } let request = c.request(entry.observed).map_err(|e| c.error(e))?; let proof = c.proof().map_err(|e| c.error(e))?; - let outcome = if reconciling { + let outcome = if let Some(admission) = c.rewrap { + let request = StockRewrapRequest::new( + request.with_envelope(entry.candidate.event_id()), + admission.rewrap_id(), + ); + if reconciling { + c.store + .reconcile_stock_rewrap(request, proof, &entry.candidate) + .await + } else { + c.store + .capture_stock_rewrap(request, proof, &entry.candidate) + .await + } + } else if reconciling { c.store .reconcile_stock_envelope(request, proof, &entry.candidate) .await @@ -112,6 +127,8 @@ impl Owner { || receipt.recipient() != c.recipient || receipt.event_id() != entry.candidate.event_id() || receipt.digest() != entry.candidate.digest() + || receipt.rewrap_admission_transaction_id() + != c.rewrap.map(|admission| admission.transaction_id()) || receipt.checkpoint().authority() != c.selection.minimum.authority() { return Err(c.error(OperationError::RecoveryRequired)); @@ -249,6 +266,7 @@ impl Owner { Ok(()) } pub(super) async fn drain_delivery(&self) -> crate::Result<()> { + self.drain_rewrap_admissions().await?; loop { let entry = self .envelopes diff --git a/crates/execution/src/session/stock_evidence.rs b/crates/execution/src/session/stock_evidence.rs @@ -16,6 +16,9 @@ pub(super) use unissued::RetainedUnissued; #[path = "stock_delivery.rs"] mod delivery; pub(super) use delivery::{DeliveryContext, RetainedDelivery, RetainedEnvelope}; +#[path = "stock_rewrap.rs"] +mod rewrap; +pub(super) use rewrap::RetainedAdmission; pub(super) struct Pending { store: Shared<dyn InventoryStore>, @@ -31,6 +34,7 @@ pub(super) struct Owner { unissued: Mutex<Vec<Shared<RetainedUnissued>>>, envelopes: Mutex<Vec<Shared<RetainedEnvelope>>>, deliveries: Mutex<Vec<Shared<RetainedDelivery>>>, + rewraps: Mutex<Vec<Shared<RetainedAdmission>>>, pub(super) delivery_serial: futures::lock::Mutex<()>, serial: futures::lock::Mutex<()>, } @@ -58,11 +62,16 @@ impl Owner { .deliveries .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); + let rewraps = self + .rewraps + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); if pending.is_empty() && unmapped.is_empty() && unissued.is_empty() && envelopes.is_empty() && deliveries.is_empty() + && rewraps.is_empty() { Ok(()) } else { diff --git a/crates/execution/src/session/stock_rewrap.rs b/crates/execution/src/session/stock_rewrap.rs @@ -0,0 +1,103 @@ +//! Original admission credentials survive uncertainty; repair grants no invocation. +use super::delivery::DeliveryContext; +use super::*; +use radroots_domain::OperationId; +use radroots_storage::inventory::{StockEnvelopeReceipt, StockRewrapOutcome, StockRewrapRequest}; + +pub(in crate::session) struct RetainedAdmission { + context: DeliveryContext, + original: StockEnvelopeReceipt, + id: OperationId, +} +impl Owner { + pub(in crate::session) fn retain_rewrap_admission( + &self, + context: DeliveryContext, + original: StockEnvelopeReceipt, + id: OperationId, + ) -> Shared<RetainedAdmission> { + let entry = Shared::new(RetainedAdmission { + context, + original, + id, + }); + self.rewraps + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .push(entry.clone()); + entry + } + pub(in crate::session) async fn prepare_rewrap( + &self, + entry: &Shared<RetainedAdmission>, + ) -> crate::Result<StockRewrapOutcome> { + let _serial = self.serial.lock().await; + let c = &entry.context; + let request = StockRewrapRequest::new(c.request(None).map_err(|e| c.error(e))?, entry.id); + let result = c + .store + .prepare_stock_rewrap(request, c.proof().map_err(|e| c.error(e))?) + .await + .map_err(|e| c.error(e))?; + match &result { + StockRewrapOutcome::Claimed(admitted) | StockRewrapOutcome::Retained(admitted) => { + if admitted.rewrap_id() != entry.id + || admitted.original() != entry.original + || admitted.checkpoint().authority() != c.selection.minimum.authority() + || admitted.checkpoint().revision() <= entry.original.checkpoint().revision() + || (matches!(&result, StockRewrapOutcome::Claimed(_)) + && admitted.checkpoint().revision() <= c.selection.minimum.revision()) + { + return Err(c.error(OperationError::RecoveryRequired)); + } + self.finish_rewrap_admission(entry); + } + StockRewrapOutcome::Unknown(attempt) => { + if attempt.workspace_id() != c.selection.binding.input().workspace_id() + || attempt.operation_id() != c.selection.operation + || attempt.command_digest() != c.selection.digest + { + return Err(c.error(OperationError::RecoveryRequired)); + } + // Neither an unknown write nor a lost waiter may create keys. + // Keep original proof, store and task/byte lease until repair. + } + } + Ok(result) + } + fn finish_rewrap_admission(&self, entry: &Shared<RetainedAdmission>) { + let removed = { + let mut entries = self + .rewraps + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + entries + .iter() + .position(|v| Shared::ptr_eq(v, entry)) + .map(|index| entries.remove(index)) + }; + drop(removed); + } + /// Called under the existing capture serial lock. This repairs the writer + /// fence only; status reads still require current access and consent. + pub(super) async fn drain_rewrap_admissions(&self) -> crate::Result<()> { + loop { + let entry = self + .rewraps + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .first() + .cloned(); + let Some(entry) = entry else { return Ok(()) }; + let c = &entry.context; + c.store + .reconcile_stock_rewrap_admission( + StockRewrapRequest::new(c.request(None).map_err(|e| c.error(e))?, entry.id), + c.proof().map_err(|e| c.error(e))?, + ) + .await + .map_err(|e| c.error(e))?; + self.finish_rewrap_admission(&entry); + } + } +} diff --git a/crates/radroots/src/native_commerce_tests.rs b/crates/radroots/src/native_commerce_tests.rs @@ -921,6 +921,8 @@ async fn lost_observer_cannot_discard_actual_peer_artifact_and_close_installs_be mod delivery; #[path = "native_refusal_tests.rs"] mod original_refusals; +#[path = "native_stock_rewrap_tests.rs"] +mod rewrap; #[tokio::test] async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_recovery() { diff --git a/crates/radroots/src/native_stock_rewrap_tests.rs b/crates/radroots/src/native_stock_rewrap_tests.rs @@ -0,0 +1,564 @@ +//! Ordinary explicit wrapping and exact recovery use the real protected owner. +use super::*; +fn peer_index(r: &Rig, status: &crate::orders::AcceptanceStatus) -> usize { + status + .recipients() + .iter() + .position(|entry| entry.recipient != r.enrollment.input().participant()) + .unwrap() +} +#[tokio::test] +async fn ordinary_rewrap_is_explicit_preserves_originals_and_resumes_exact_bytes_without_signing() { + let r = Rig::new().await; + let (command, initial) = r.accept().await; + let index = peer_index(&r, &initial); + let recipient = initial.recipients()[index].recipient; + let original = initial.delivery().unwrap()[index].source().unwrap(); + let id = OperationId::from_bytes([71; 32]); + let (_, _, minimum) = r.minima().await; + r.io.missing_ack.store(true, Ordering::SeqCst); + let first = r + .client + .orders(&r.scope) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + let state = first.state().unwrap(); + let outer = state.envelope().unwrap(); + assert_eq!(state.admission().original(), original); + assert_ne!(outer.event_id(), original.event_id()); + assert_eq!(outer.evidence(), original.evidence()); + assert_eq!( + outer.installation_transaction_id(), + original.installation_transaction_id() + ); + let summary = first.delivery().unwrap(); + assert_eq!(summary.attempt_count(), 2); + assert_eq!(summary.selected_attempt_count(), 1); + assert!(!summary.acceptance_satisfied().unwrap()); + assert_eq!(summary.publication_policy_source(), Some(original)); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + let sent = r.io.sent.lock().unwrap().clone(); + assert_eq!(sent.len(), 3); + let raw = sent[2].clone(); + let repeated = r + .client + .orders(&r.scope) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + assert_eq!(repeated.state(), Some(state)); + assert_eq!(r.io.sent.lock().unwrap().len(), 3); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + let observed = r + .client + .orders(&r.scope) + .acceptance_status(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_eq!(observed.installation(), initial.installation()); + let old = &observed.delivery().unwrap()[index]; + assert_eq!(old.source(), Some(original)); + assert_eq!(old.attempt_count(), 2); + assert_eq!(old.selected_attempt_count(), 1); + assert!(old.acceptance_satisfied().unwrap()); + let read = r + .client + .orders(&r.scope) + .acceptance_rewrap_status( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + assert_eq!(read.state(), Some(state)); + assert_eq!(r.io.sent.lock().unwrap().len(), 3); + r.io.missing_ack.store(false, Ordering::SeqCst); + let resumed = r + .client + .orders(&r.scope) + .resume_acceptance_rewrap( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + assert_eq!(resumed.state(), Some(state)); + assert_eq!(resumed.delivery().unwrap().attempt_count(), 3); + assert_eq!(resumed.delivery().unwrap().selected_attempt_count(), 2); + assert!(resumed.delivery().unwrap().acceptance_satisfied().unwrap()); + assert_eq!(r.io.sent.lock().unwrap()[3], raw); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + r.client.close().await.unwrap(); +} + +async fn fault_connection(r: &Rig) -> sqlx::SqliteConnection { + use sqlx::Connection; + let path = r._temp.path().join("stock/stock_execution_v1.sqlite"); + sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())) + .await + .unwrap() +} +async fn original_entries(c: &mut sqlx::SqliteConnection) -> (Vec<Vec<u8>>, Vec<Vec<u8>>) { + let outers = sqlx::query_scalar("SELECT entry_id FROM stock_envelopes ORDER BY entry_id") + .fetch_all(&mut *c) + .await + .unwrap(); + let seals = sqlx::query_scalar("SELECT entry_id FROM stock_signing_evidence ORDER BY entry_id") + .fetch_all(c) + .await + .unwrap(); + (outers, seals) +} + +#[tokio::test] +async fn obtained_rewrap_survives_statement_and_commit_failure_and_clockless_failed_close() { + use sqlx::Connection; + for uncertain in [false, true] { + let r = Rig::new().await; + let (command, initial) = r.accept().await; + let recipient = initial.recipients()[peer_index(&r, &initial)].recipient; + let (_, _, minimum) = r.minima().await; + let mut fault = fault_connection(&r).await; + let originals = original_entries(&mut fault).await; + if uncertain { + sqlx::raw_sql("CREATE TABLE rewrap_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_rewrap_failure AFTER INSERT ON stock_rewraps BEGIN INSERT INTO rewrap_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap(); + } else { + sqlx::query("CREATE TRIGGER controlled_rewrap_failure BEFORE INSERT ON stock_rewraps BEGIN SELECT RAISE(ABORT, 'controlled_rewrap_failure'); END").execute(&mut fault).await.unwrap(); + } + let error = r + .client + .orders(&r.scope) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + OperationId::from_bytes([72; 32]), + ) + .await + .unwrap_err(); + assert_eq!( + error.code(), + if uncertain { + crate::Code::RecoveryRequired + } else { + crate::Code::StorageFailure + } + ); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.io.sent.lock().unwrap().len(), 2); + r.clock.0.store(0, Ordering::SeqCst); + assert!(r.client.close().await.is_err()); + assert!(r.provider.upgrade().is_some()); + sqlx::raw_sql( + "DROP TRIGGER controlled_rewrap_failure; DROP TABLE IF EXISTS rewrap_deferred_fault", + ) + .execute(&mut fault) + .await + .unwrap(); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); + assert_eq!(original_entries(&mut fault).await, originals); + let counts: (i64, i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_rewrap_admissions),(SELECT count(*) FROM stock_rewraps)").fetch_one(&mut fault).await.unwrap(); + assert_eq!(counts, (1, 1)); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.io.sent.lock().unwrap().len(), 2); + fault.close().await.unwrap(); + } +} + +#[tokio::test] +async fn failed_rewrap_admission_repairs_without_a_key_or_renewed_invocation() { + use sqlx::Connection; + for uncertain in [false, true] { + let r = Rig::new().await; + let (command, initial) = r.accept().await; + let recipient = initial.recipients()[peer_index(&r, &initial)].recipient; + let (_, _, minimum) = r.minima().await; + let id = OperationId::from_bytes([73; 32]); + let mut fault = fault_connection(&r).await; + let originals = original_entries(&mut fault).await; + if uncertain { + sqlx::raw_sql("CREATE TABLE admission_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_admission_failure AFTER INSERT ON stock_rewrap_admissions BEGIN INSERT INTO admission_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap(); + } else { + sqlx::query("CREATE TRIGGER controlled_admission_failure BEFORE INSERT ON stock_rewrap_admissions BEGIN SELECT RAISE(ABORT, 'controlled_admission_failure'); END").execute(&mut fault).await.unwrap(); + } + let error = r + .client + .orders(&r.scope) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap_err(); + assert_eq!( + error.code(), + if uncertain { + crate::Code::RecoveryRequired + } else { + crate::Code::StorageFailure + } + ); + r.clock.0.store(0, Ordering::SeqCst); + sqlx::raw_sql("DROP TRIGGER controlled_admission_failure; DROP TABLE IF EXISTS admission_deferred_fault").execute(&mut fault).await.unwrap(); + // Restore the exact catalog before uncertain-connection reopen. Repair + // then resolves only the original writer fence, without a current clock, + // a fresh admission or an invocation right. + r.client.stock(&r.scope).drain_evidence().await.unwrap(); + r.clock.0.store(150, Ordering::SeqCst); + let view = r + .client + .orders(&r.scope) + .resume_acceptance_rewrap( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + assert!(view.state().is_none()); + assert!(view.delivery().is_none()); + assert_eq!(original_entries(&mut fault).await, originals); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 2); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.io.sent.lock().unwrap().len(), 2); + r.client.close().await.unwrap(); + fault.close().await.unwrap(); + } +} + +#[tokio::test] +async fn obtained_rewrap_delivery_survives_lost_waiter_commit_failure_and_clock_loss() { + use sqlx::Connection; + for uncertain in [false, true] { + let r = Rig::new().await; + let (command, initial) = r.accept().await; + let recipient = initial.recipients()[peer_index(&r, &initial)].recipient; + let (_, _, minimum) = r.minima().await; + r.io.pause_delivery.store(true, Ordering::SeqCst); + let client = r.client.clone(); + let scope = r.scope.clone(); + let waiter = tokio::spawn(async move { + client + .orders(&scope) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + OperationId::from_bytes([74; 32]), + ) + .await + }); + tokio::time::timeout(std::time::Duration::from_secs(120), r.io.entered.notified()) + .await + .unwrap(); + waiter.abort(); + assert!(waiter.await.unwrap_err().is_cancelled()); + let mut fault = fault_connection(&r).await; + let originals = original_entries(&mut fault).await; + let attempts: Vec<(Vec<u8>, Vec<u8>)> = sqlx::query_as( + "SELECT entry_id,request_key FROM stock_delivery_attempts ORDER BY entry_id", + ) + .fetch_all(&mut fault) + .await + .unwrap(); + let observations: i64 = + sqlx::query_scalar("SELECT count(*) FROM stock_delivery_observations") + .fetch_one(&mut fault) + .await + .unwrap(); + if uncertain { + sqlx::raw_sql("CREATE TABLE rewrap_observation_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_rewrap_observation AFTER INSERT ON stock_delivery_observations BEGIN INSERT INTO rewrap_observation_fault VALUES(2); END").execute(&mut fault).await.unwrap(); + } else { + sqlx::query("CREATE TRIGGER controlled_rewrap_observation BEFORE INSERT ON stock_delivery_observations BEGIN SELECT RAISE(ABORT, 'controlled_rewrap_observation'); END").execute(&mut fault).await.unwrap(); + } + r.clock.0.store(0, Ordering::SeqCst); + r.io.release.notify_one(); + let error = r.client.close().await.unwrap_err(); + assert_eq!( + error.code(), + if uncertain { + crate::Code::RecoveryRequired + } else { + crate::Code::StorageFailure + } + ); + assert!(r.provider.upgrade().is_some()); + sqlx::raw_sql("DROP TRIGGER controlled_rewrap_observation; DROP TABLE IF EXISTS rewrap_observation_fault").execute(&mut fault).await.unwrap(); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); + assert_eq!(original_entries(&mut fault).await, originals); + let actual: Vec<(Vec<u8>, Vec<u8>)> = sqlx::query_as( + "SELECT entry_id,request_key FROM stock_delivery_attempts ORDER BY entry_id", + ) + .fetch_all(&mut fault) + .await + .unwrap(); + assert_eq!(actual, attempts); + let actual: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_delivery_observations") + .fetch_one(&mut fault) + .await + .unwrap(); + assert_eq!(actual, observations + 1); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.io.sent.lock().unwrap().len(), 3); + fault.close().await.unwrap(); + } +} + +#[tokio::test] +async fn rewrap_loopback_scopes_partial_acknowledgement_and_retries_exact_bytes_without_signing() { + use futures::{SinkExt, StreamExt}; + use radroots_transport_nostr::{ + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, + }; + use std::time::{Duration, SystemTime, UNIX_EPOCH}; + use tokio_tungstenite::{accept_async, tungstenite::Message}; + async fn relay(listener: tokio::net::TcpListener, partial: bool) -> Vec<String> { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let mut frames = Vec::new(); + for index in 0..if partial { 2 } else { 1 } { + let frame = tokio::time::timeout(Duration::from_secs(300), async { + loop { + if let Message::Text(raw) = socket.next().await.unwrap().unwrap() { + let event: serde_json::Value = serde_json::from_str(&raw).unwrap(); + if event[0] == "EVENT" { + break (raw.to_string(), event[1]["id"].clone()); + } + } + } + }) + .await + .unwrap(); + socket + .send(Message::Text( + serde_json::json!(["OK", "ff".repeat(32), true, ""]) + .to_string() + .into(), + )) + .await + .unwrap(); + socket + .send(Message::Text( + serde_json::json!(["OK", frame.1, !partial || index > 0, ""]) + .to_string() + .into(), + )) + .await + .unwrap(); + frames.push(frame.0); + } + // Keep the accepted relay connected through the second invocation, so + // skipping it is actual target selection rather than disconnect luck. + if !partial { + while let Some(message) = socket.next().await { + match message.unwrap() { + Message::Text(raw) => { + let value: serde_json::Value = serde_json::from_str(&raw).unwrap(); + assert_ne!(value[0], "EVENT", "accepted target must not be retried"); + } + Message::Close(_) => break, + _ => {} + } + } + } + frames + } + let first = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let second = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let uris = vec![ + format!("ws://{}", first.local_addr().unwrap()), + format!("ws://{}", second.local_addr().unwrap()), + ]; + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_secs(); + let r = Rig::configured(Some(uris.clone()), now + 1800).await; + r.io.missing_ack.store(true, Ordering::SeqCst); + let (command, initial) = r.accept().await; + let index = peer_index(&r, &initial); + let recipient = initial.recipients()[index].recipient; + let original = initial.delivery().unwrap()[index].source().unwrap(); + let originals = r.io.sent.lock().unwrap().clone(); + let accepted = tokio::spawn(relay(first, false)); + let partial = tokio::spawn(relay(second, true)); + let config = Config::from_profile( + RelayProfile::explicit( + RelayProfileKind::Simulator, + uris.iter().map(|uri| { + RelayEndpoint::new(uri, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap() + }), + ) + .unwrap(), + ) + .with_timeouts(1000, 1000, 500) + .unwrap(); + let transport = Arc::new(radroots_transport_nostr_native::create_transport(config)); + *r.io.transport.lock().unwrap() = Some(transport.clone()); + r.clock.enable_realtime(); + let (_, _, minimum) = r.minima().await; + let grant = StockGrantEnrollment::prepare( + &SellerAuthoritySelection::from_attachment(r.enrollment.input()), + "explicit wrapping recovery".into(), + UnixSeconds::new(now + 1500).unwrap(), + StockGrantScope::full_inventory(), + ) + .unwrap(); + r.native + .enroll_stock_grant( + r.scope.binding().clone(), + minimum, + r.enrollment.proof(), + &grant, + ) + .await + .unwrap(); + let (_, _, minimum) = r.minima().await; + let capture = StockConsentCapture::prepare( + SellerAuthoritySelection::from_attachment(r.enrollment.input()), + grant.input().grant_id(), + StockConsentMode::RecoverOnly, + StockResources::all_pools(), + UnixSeconds::new(now + 1200).unwrap(), + CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), + ) + .unwrap(); + r.native + .issue_stock_consent( + r.scope.binding().clone(), + minimum, + &capture, + r.enrollment.proof(), + ) + .await + .unwrap(); + let (_, _, minimum) = r.minima().await; + let recovery = r + .client + .attach(grant.input().clone(), proof(grant.proof())) + .await + .unwrap(); + let id = OperationId::from_bytes([75; 32]); + let first = r + .client + .orders(&recovery) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + let state = first.state().unwrap(); + let summary = first.delivery().unwrap(); + assert_eq!(state.admission().original(), original); + assert_eq!(summary.attempt_count(), 2); + assert_eq!(summary.selected_attempt_count(), 1); + assert!(!summary.acceptance_satisfied().unwrap()); + assert_eq!(summary.targets().iter().filter(|v| v.accepted()).count(), 1); + let repeated = r + .client + .orders(&recovery) + .rewrap_acceptance( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + assert_eq!(repeated.state(), Some(state)); + assert_eq!(r.io.sent.lock().unwrap().len(), 3); + let resumed = r + .client + .orders(&recovery) + .resume_acceptance_rewrap( + minimum, + command.context().operation_id(), + command.digest(), + recipient, + id, + ) + .await + .unwrap(); + assert_eq!(resumed.state(), Some(state)); + let summary = resumed.delivery().unwrap(); + assert_eq!(summary.attempt_count(), 3); + assert_eq!(summary.selected_attempt_count(), 2); + assert!(summary.acceptance_satisfied().unwrap()); + let mut counts: Vec<_> = summary + .targets() + .iter() + .map(|v| v.potential_attempts()) + .collect(); + counts.sort(); + assert_eq!(counts, [2, 3]); + let observed = r + .client + .orders(&recovery) + .acceptance_status(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_eq!(observed.installation(), initial.installation()); + let old = &observed.delivery().unwrap()[index]; + assert_eq!(old.source(), Some(original)); + assert_eq!(old.selected_attempt_count(), 1); + assert!(!old.acceptance_satisfied().unwrap()); + let sent = r.io.sent.lock().unwrap().clone(); + assert_eq!(&sent[..2], originals.as_slice()); + assert_eq!(sent[2], sent[3]); + assert!(!originals.contains(&sent[2])); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); + transport.shutdown().await; + let accepted = tokio::time::timeout(Duration::from_secs(10), accepted) + .await + .unwrap() + .unwrap(); + let partial = tokio::time::timeout(Duration::from_secs(10), partial) + .await + .unwrap() + .unwrap(); + assert_eq!(accepted.len(), 1); + assert_eq!(partial.len(), 2); + assert_eq!(accepted[0], partial[0]); + assert_eq!(partial[0], partial[1]); + assert_eq!(accepted[0], format!("[\"EVENT\",{}]", sent[2])); + r.client.close().await.unwrap(); +} diff --git a/crates/radroots/src/orders.rs b/crates/radroots/src/orders.rs @@ -2,7 +2,8 @@ use crate::{Client, CommandContext, Result, WorkspaceSession}; use radroots_domain::{CommandDigest, OperationId}; pub use radroots_execution::session::commerce::{ - AcceptanceRecipient, AcceptanceStatus, AcceptanceUnissuedReceipt, InstalledAcceptance, + AcceptanceRecipient, AcceptanceRewrapStatus, AcceptanceStatus, AcceptanceUnissuedReceipt, + InstalledAcceptance, }; pub use radroots_protocol::command::AcceptOrderInput; use radroots_storage::{ @@ -84,4 +85,74 @@ impl<'a> Orders<'a> { ) .await } + /// Creates one explicitly requested additional carrier for the same original + /// commitment. Existing/unknown admissions never generate another key. + pub async fn rewrap_acceptance( + &self, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: radroots_domain::PublicKey, + rewrap_id: OperationId, + ) -> crate::ExecutionResult<AcceptanceRewrapStatus> { + self.client + .session + .rewrap_stock_acceptance( + self.client.inventory()?, + self.client.acceptance_store()?, + &self.scope, + minimum, + operation, + digest, + recipient, + rewrap_id, + ) + .await + } + /// Explicitly retries only a known captured carrier within its original + /// policy and cumulative invocation budget. Unknown bytes never regenerate. + pub async fn resume_acceptance_rewrap( + &self, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: radroots_domain::PublicKey, + rewrap_id: OperationId, + ) -> crate::ExecutionResult<AcceptanceRewrapStatus> { + self.client + .session + .resume_stock_rewrap( + self.client.inventory()?, + self.client.acceptance_store()?, + &self.scope, + minimum, + operation, + digest, + recipient, + rewrap_id, + ) + .await + } + /// Reads retained carrier facts without wrapping, signing or dispatch. + pub async fn acceptance_rewrap_status( + &self, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + recipient: radroots_domain::PublicKey, + rewrap_id: OperationId, + ) -> Result<AcceptanceRewrapStatus> { + self.client + .session + .stock_acceptance_rewrap_status( + self.client.inventory()?, + &self.scope, + minimum, + operation, + digest, + recipient, + rewrap_id, + ) + .await + } } diff --git a/crates/storage/src/inventory/delivery_state.rs b/crates/storage/src/inventory/delivery_state.rs @@ -75,6 +75,7 @@ pub struct StockDeliverySummary { first: Option<DeliveryIntent>, policy_source: Option<StockEnvelopeReceipt>, attempts: u16, + selected_attempts: u16, targets: Box<[StockDeliveryTargetProgress]>, checkpoint: InventoryCheckpointRef, } @@ -96,6 +97,7 @@ impl StockDeliverySummary { policy_source, first, attempts, + attempts, targets, checkpoint, ) @@ -103,18 +105,26 @@ impl StockDeliverySummary { /// Validates an envelope-scoped projection while retaining the actual first /// publication policy's source. A new carrier cannot renew its target set, /// criterion or cumulative invocation budget. Reports grant no dispatch. + #[allow(clippy::too_many_arguments)] pub fn from_store_report_with_policy_source( request: &StockEnvelopeRequest, source: Option<StockEnvelopeReceipt>, policy_source: Option<StockEnvelopeReceipt>, first: Option<DeliveryIntent>, attempts: u16, + selected_attempts: u16, targets: Vec<StockDeliveryTargetProgress>, checkpoint: InventoryCheckpointRef, ) -> Result<Self, OperationError> { if checkpoint.authority() != request.binding().input().authority() || checkpoint.revision().get() == 0 || attempts > 16 * 12 + || selected_attempts > attempts + || (selected_attempts == 0 + && targets + .iter() + .any(|target| target.accepted || target.last.is_some())) + || (source.is_none() && selected_attempts != 0) || targets.len() > 16 { return Err(OperationError::RecoveryRequired); @@ -184,6 +194,7 @@ impl StockDeliverySummary { first, policy_source, attempts, + selected_attempts, targets: targets.into_boxed_slice(), checkpoint, }) @@ -202,6 +213,11 @@ impl StockDeliverySummary { pub const fn attempt_count(&self) -> u16 { self.attempts } + /// Potential invocations for the selected exact outer, independent of the + /// cumulative count used to enforce the shared recipient/endpoint quotas. + pub const fn selected_attempt_count(&self) -> u16 { + self.selected_attempts + } pub fn targets(&self) -> &[StockDeliveryTargetProgress] { &self.targets } diff --git a/crates/storage/tests/workspace/inventory_delivery.rs b/crates/storage/tests/workspace/inventory_delivery.rs @@ -141,6 +141,7 @@ fn selected_envelope_retains_a_separate_first_policy_source_without_weakening_or Some(original), Some(intent.clone()), 1, + 1, progress(&intent, &[false, false]), checkpoint(4), ) @@ -157,6 +158,7 @@ fn selected_envelope_retains_a_separate_first_policy_source_without_weakening_or Some(wrong_policy), Some(intent.clone()), 1, + 1, progress(&intent, &[false, false]), checkpoint(5) ) @@ -378,3 +380,71 @@ fn stock_intent_refuses_public_artifacts_and_empty_outcome_pages_do_not_advance( "StockDeliveryObservationPage(<redacted>)" ); } + +#[test] +fn scoped_delivery_counts_refuse_observations_without_a_selected_invocation() { + let (request, original, intent) = fixture(); + let new = rewrapped(&request, original, 1); + let selected = StockEnvelopeRequest::new( + request.binding().clone(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), + request.recipient(), + None, + ) + .unwrap() + .with_envelope(new.event_id()); + let none = StockDeliverySummary::from_store_report_with_policy_source( + &selected, + Some(new), + Some(original), + Some(intent.clone()), + 1, + 0, + progress(&intent, &[false, false]) + .into_iter() + .map(|target| { + StockDeliveryTargetProgress::from_store_report( + target.target().clone(), + target.potential_attempts(), + false, + None, + None, + ) + .unwrap() + }) + .collect(), + checkpoint(5), + ) + .unwrap(); + assert_eq!(none.attempt_count(), 1); + assert_eq!(none.selected_attempt_count(), 0); + assert!(!none.acceptance_satisfied().unwrap()); + assert!( + StockDeliverySummary::from_store_report_with_policy_source( + &selected, + Some(new), + Some(original), + Some(intent.clone()), + 1, + 2, + progress(&intent, &[false, false]), + checkpoint(5) + ) + .is_err() + ); + assert!( + StockDeliverySummary::from_store_report_with_policy_source( + &selected, + Some(new), + Some(original), + Some(intent.clone()), + 1, + 0, + progress(&intent, &[true, false]), + checkpoint(5) + ) + .is_err() + ); +} diff --git a/crates/storage_sqlite/src/workspace/stock/delivery/graph.rs b/crates/storage_sqlite/src/workspace/stock/delivery/graph.rs @@ -15,6 +15,7 @@ struct Recipient { first: Option<DeliveryIntent>, first_source: Option<radroots_storage::inventory::StockEnvelopeReceipt>, attempts: u16, + selected_attempts: u16, endpoints: Vec<Endpoint>, } impl Recipient { @@ -67,6 +68,14 @@ impl Recipient { .attempts .checked_add(1) .ok_or(OperationError::RecoveryRequired)?; + if self.source.as_ref().is_some_and(|source| { + source.source.receipt().event_id() == value.source().receipt().event_id() + }) { + self.selected_attempts = self + .selected_attempts + .checked_add(1) + .ok_or(OperationError::RecoveryRequired)?; + } if self.attempts > 16 * 12 { return Err(OperationError::RecoveryRequired); } @@ -162,6 +171,7 @@ impl Graph { first: None, first_source: None, attempts: 0, + selected_attempts: 0, endpoints: vec![], }); } @@ -173,7 +183,7 @@ impl Graph { found_observation: None, last_at: None, }; - let rows = sqlx::query("SELECT d.entry_id FROM stock_delivery_attempts d JOIN stock_operations o ON o.actor=d.actor AND o.operation_id=d.entry_id WHERE d.actor=? AND d.operation_id=? ORDER BY o.revision LIMIT 385") + let rows = sqlx::query("SELECT CASE WHEN length(d.entry_id)=32 THEN d.entry_id END FROM stock_delivery_attempts d JOIN stock_operations o ON o.actor=d.actor AND o.operation_id=d.entry_id WHERE d.actor=? AND d.operation_id=? ORDER BY o.revision LIMIT 385") .bind(turn.selected.participant().as_bytes().as_slice()).bind(request.operation_id().as_bytes().as_slice()) .fetch_all(&mut *turn.connection).await.map_err(|_|OperationError::RecoveryRequired)?; if rows.len() > ATTEMPT_COUNT_MAX { @@ -212,7 +222,7 @@ impl Graph { result.found_attempt = Some(value); } } - let rows = sqlx::query("SELECT d.entry_id FROM stock_delivery_observations d JOIN stock_operations o ON o.actor=d.actor AND o.operation_id=d.entry_id WHERE d.actor=? AND d.operation_id=? ORDER BY o.revision LIMIT 2305") + let rows = sqlx::query("SELECT CASE WHEN length(d.entry_id)=32 THEN d.entry_id END FROM stock_delivery_observations d JOIN stock_operations o ON o.actor=d.actor AND o.operation_id=d.entry_id WHERE d.actor=? AND d.operation_id=? ORDER BY o.revision LIMIT 2305") .bind(turn.selected.participant().as_bytes().as_slice()).bind(request.operation_id().as_bytes().as_slice()) .fetch_all(&mut *turn.connection).await.map_err(|_|OperationError::RecoveryRequired)?; if rows.len() > OBSERVATION_COUNT_MAX { @@ -327,6 +337,7 @@ impl Graph { value.first_source, value.first.clone(), value.attempts, + value.selected_attempts, targets, checkpoint, ) 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 @@ -222,6 +222,8 @@ async fn rewrapping_delivery_preserves_global_policy_and_counters_but_scopes_acc assert_eq!(selected_summary.original_intent(), Some(initial.intent())); assert_eq!(original_summary.attempt_count(), 2); assert_eq!(selected_summary.attempt_count(), 2); + assert_eq!(selected_summary.selected_attempt_count(), 1); + assert_eq!(original_summary.selected_attempt_count(), 1); assert_eq!(selected_summary.targets()[0].potential_attempts(), 2); let accepted = save(&r, &observed(&attempt, DeliveryOutcome::accepted(), None)).await; let page = r @@ -343,6 +345,8 @@ async fn rewrapping_first_delivery_does_not_fabricate_original_envelope_acceptan assert_eq!(old.source(), Some(first)); assert_eq!(old.publication_policy_source(), Some(saved)); assert_eq!(old.attempt_count(), 1); + assert_eq!(old.selected_attempt_count(), 0); + assert_eq!(new_summary.selected_attempt_count(), 1); let page = r .store .stock_delivery_observations( diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -143,6 +143,10 @@ struct StockRewrapping { unknown_admissions_count_toward_limit: bool, descriptor_includes_uncaptured_admissions: bool, admission_repair_grants_history_or_invocation: bool, + ordinary_owner: String, + ordinary_facade_methods: Vec<String>, + ordinary_resume_generates_key_or_business_signature: bool, + ordinary_status_is_atomic_absence_proof: bool, payload_version: u16, payload_prefix_bytes: u32, @@ -299,6 +303,7 @@ struct StockDelivery { first_complete_targets_and_criterion_immutable: bool, ordinary_command_replays_existing_attempt: bool, ordinary_fresh_claim_binds_observed_attempt_count: bool, + ordinary_repeat_uses_selected_envelope_attempt_count: bool, ordinary_obtained_material_owner: String, ordinary_peer_delivery_precedes_self_signing: bool, installed_original_delivery_requires_signer: bool, @@ -771,6 +776,15 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && rewrap.unknown_admissions_count_toward_limit && rewrap.descriptor_includes_uncaptured_admissions && !rewrap.admission_repair_grants_history_or_invocation + && rewrap.ordinary_owner == "ClientSession.stock_captures" + && rewrap.ordinary_facade_methods + == [ + "Orders.rewrap_acceptance", + "Orders.resume_acceptance_rewrap", + "Orders.acceptance_rewrap_status", + ] + && !rewrap.ordinary_resume_generates_key_or_business_signature + && !rewrap.ordinary_status_is_atomic_absence_proof && rewrap.payload_version == 1 && rewrap.payload_prefix_bytes == 117 && rewrap.supported_catalogs == [18] @@ -837,6 +851,7 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && delivery.first_complete_targets_and_criterion_immutable && !delivery.ordinary_command_replays_existing_attempt && delivery.ordinary_fresh_claim_binds_observed_attempt_count + && delivery.ordinary_repeat_uses_selected_envelope_attempt_count && delivery.ordinary_obtained_material_owner == "ClientSession.stock_captures" && delivery.ordinary_peer_delivery_precedes_self_signing && !delivery.installed_original_delivery_requires_signer @@ -2545,6 +2560,13 @@ mod tests { ("unknown_admissions_count_toward_limit", json!(false)), ("descriptor_includes_uncaptured_admissions", json!(false)), ("admission_repair_grants_history_or_invocation", json!(true)), + ("ordinary_owner", json!("application")), + ("ordinary_facade_methods", json!([])), + ( + "ordinary_resume_generates_key_or_business_signature", + json!(true), + ), + ("ordinary_status_is_atomic_absence_proof", json!(true)), ("supported_catalogs", json!([17, 18])), ("payload_prefix_bytes", json!(118)), ("additional_envelopes_per_recipient_max", json!(193)), @@ -2651,6 +2673,10 @@ mod tests { json!(false), ), ("ordinary_obtained_material_owner", json!("application")), + ( + "ordinary_repeat_uses_selected_envelope_attempt_count", + json!(false), + ), ("ordinary_peer_delivery_precedes_self_signing", json!(false)), ("installed_original_delivery_requires_signer", json!(true)), ("retries_use_original_outer_bytes", json!(false)),