commit e1d058d4c20e5e8651e4155f14021023c1083b13
parent 2ed3db9de1d9fb789b40ffb88e335a3681540c9c
Author: triesap <tyson@radroots.org>
Date: Tue, 27 Oct 2026 17:07:32 +0000
storage: define stock envelope retention interfaces
- Bind selectors and capture reports to original scoped operation metadata.
- Validate bounded signed carriers and preserve exact owned envelope bytes.
- Refuse unsupported capture and query without native stock or outbox writes.
- Verify native, Linux and portable boundaries with generated API additions.
Diffstat:
9 files changed, 626 insertions(+), 1 deletion(-)
diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt
@@ -1390,6 +1390,9 @@ pub enum radroots_storage::inventory::StockAcceptanceOutcome
pub radroots_storage::inventory::StockAcceptanceOutcome::Aborted(alloc::boxed::Box<radroots_storage::inventory::StockAbortReceipt>)
pub radroots_storage::inventory::StockAcceptanceOutcome::Prepared(alloc::boxed::Box<radroots_storage::inventory::StockAcceptanceReceipt>)
pub radroots_storage::inventory::StockAcceptanceOutcome::Unknown(radroots_storage::command::CommitAttempt)
+pub enum radroots_storage::inventory::StockEnvelopeOutcome
+pub radroots_storage::inventory::StockEnvelopeOutcome::Committed(alloc::boxed::Box<radroots_storage::inventory::StockEnvelopeReceipt>)
+pub radroots_storage::inventory::StockEnvelopeOutcome::Unknown(radroots_storage::command::CommitAttempt)
pub enum radroots_storage::inventory::StockEvidenceOutcome
pub radroots_storage::inventory::StockEvidenceOutcome::Committed(radroots_storage::inventory::StockEvidenceReceipt)
pub radroots_storage::inventory::StockEvidenceOutcome::Unknown(radroots_storage::command::CommitAttempt)
@@ -1472,6 +1475,38 @@ pub const fn radroots_storage::inventory::StockAcceptanceRequest::minimum_checkp
pub const fn radroots_storage::inventory::StockAcceptanceRequest::source_checkpoint(&self) -> radroots_storage::workspace::seller_stock::StockSourceCheckpointRef
impl core::fmt::Debug for radroots_storage::inventory::StockAcceptanceRequest
pub fn radroots_storage::inventory::StockAcceptanceRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage::inventory::StockEnvelopeReceipt
+impl radroots_storage::inventory::StockEnvelopeReceipt
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::digest(&self) -> &[u8; 32]
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::event_id(&self) -> radroots_domain::identifier::EnvelopeEventId
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::evidence(&self) -> radroots_storage::inventory::StockEvidenceReceipt
+pub fn radroots_storage::inventory::StockEnvelopeReceipt::from_committed_store(&radroots_storage::inventory::StockEnvelopeRequest, radroots_storage::command::CommitAttempt, radroots_storage::inventory::StockEvidenceReceipt, radroots_domain::identifier::TransactionId, radroots_domain::identifier::EnvelopeEventId, [u8; 32], radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError>
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::installation_transaction_id(&self) -> radroots_domain::identifier::TransactionId
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::observed_at_unix_ms(&self) -> core::option::Option<core::num::nonzero::NonZeroU64>
+pub const fn radroots_storage::inventory::StockEnvelopeReceipt::recipient(&self) -> radroots_identity::key::PublicKey
+impl core::fmt::Debug for radroots_storage::inventory::StockEnvelopeReceipt
+pub fn radroots_storage::inventory::StockEnvelopeReceipt::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage::inventory::StockEnvelopeRequest
+impl radroots_storage::inventory::StockEnvelopeRequest
+pub fn radroots_storage::inventory::StockEnvelopeRequest::attempt(&self) -> radroots_storage::command::CommitAttempt
+pub const fn radroots_storage::inventory::StockEnvelopeRequest::binding(&self) -> &radroots_storage::workspace::WorkspaceBinding
+pub const fn radroots_storage::inventory::StockEnvelopeRequest::command_digest(&self) -> radroots_domain::identifier::CommandDigest
+pub const fn radroots_storage::inventory::StockEnvelopeRequest::minimum_checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef
+pub fn radroots_storage::inventory::StockEnvelopeRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, core::option::Option<core::num::nonzero::NonZeroU64>) -> core::result::Result<Self, radroots_storage::command::OperationError>
+pub const fn radroots_storage::inventory::StockEnvelopeRequest::observed_at_unix_ms(&self) -> core::option::Option<core::num::nonzero::NonZeroU64>
+pub const fn radroots_storage::inventory::StockEnvelopeRequest::operation_id(&self) -> radroots_domain::identifier::OperationId
+pub const fn radroots_storage::inventory::StockEnvelopeRequest::recipient(&self) -> radroots_identity::key::PublicKey
+impl core::fmt::Debug for radroots_storage::inventory::StockEnvelopeRequest
+pub fn radroots_storage::inventory::StockEnvelopeRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_storage::inventory::StockEnvelopeSource
+impl radroots_storage::inventory::StockEnvelopeSource
+pub fn radroots_storage::inventory::StockEnvelopeSource::from_retained_wire(radroots_storage::inventory::StockEnvelopeReceipt, &str) -> core::result::Result<Self, radroots_storage::command::OperationError>
+pub const fn radroots_storage::inventory::StockEnvelopeSource::receipt(&self) -> radroots_storage::inventory::StockEnvelopeReceipt
+pub fn radroots_storage::inventory::StockEnvelopeSource::with_json<T>(&self, impl core::ops::function::FnOnce(&str) -> T) -> T
+impl core::fmt::Debug for radroots_storage::inventory::StockEnvelopeSource
+pub fn radroots_storage::inventory::StockEnvelopeSource::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
pub struct radroots_storage::inventory::StockEvidenceReceipt
impl radroots_storage::inventory::StockEvidenceReceipt
pub const fn radroots_storage::inventory::StockEvidenceReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt
@@ -1498,6 +1533,7 @@ impl core::fmt::Debug for radroots_storage::inventory::StockEvidenceRequest
pub fn radroots_storage::inventory::StockEvidenceRequest::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::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::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>>
@@ -1505,6 +1541,7 @@ pub fn radroots_storage::inventory::InventoryStore::option_mapping(&self, radroo
pub fn radroots_storage::inventory::InventoryStore::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>>
pub fn radroots_storage::inventory::InventoryStore::prepare_stock_acceptance(&self, radroots_storage::inventory::StockAcceptanceRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockAcceptanceOutcome, radroots_storage::command::OperationError>>
pub fn radroots_storage::inventory::InventoryStore::reconcile_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::stock_envelope(&self, radroots_storage::inventory::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::StockEnvelopeSource>, radroots_storage::command::OperationError>>
pub fn radroots_storage::inventory::InventoryStore::stock_preparation_abort(&self, radroots_storage::inventory::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::StockAbortReceipt>, radroots_storage::command::OperationError>>
pub mod radroots_storage::journal
pub use radroots_storage::journal::BoxFuture
diff --git a/crates/storage/src/command.rs b/crates/storage/src/command.rs
@@ -16,6 +16,8 @@ use radroots_transport::BoxFuture;
pub mod protected;
mod delivery;
+#[cfg(feature = "protected_outbox")]
+pub(crate) use delivery::outer as verified_private_outer;
mod delivery_summary;
mod dm_source;
mod installation;
diff --git a/crates/storage/src/command/delivery.rs b/crates/storage/src/command/delivery.rs
@@ -27,7 +27,7 @@ pub use self::private::PrivateEnvelopeCandidate;
const SIGNED_MAX_BYTES: usize = 65_536;
const MAX_TIME: u64 = 253_402_300_799;
-fn outer(raw: &str, recipient: PublicKey) -> Result<SignedEvent, OperationError> {
+pub(crate) fn outer(raw: &str, recipient: PublicKey) -> Result<SignedEvent, OperationError> {
if raw.len() > SIGNED_MAX_BYTES {
return Err(OperationError::InvalidEvidence);
}
diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs
@@ -9,9 +9,13 @@ pub use radroots_protocol::command::{CapturedInventoryCommand, InventoryCommandK
use radroots_transport::BoxFuture;
mod abort;
mod acceptance;
+mod envelope;
mod evidence;
pub use abort::{StockAbortOutcome, StockAbortReceipt, StockAbortRequest};
pub use acceptance::{StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest};
+pub use envelope::{
+ StockEnvelopeOutcome, StockEnvelopeReceipt, StockEnvelopeRequest, StockEnvelopeSource,
+};
pub use evidence::{StockEvidenceOutcome, StockEvidenceReceipt, StockEvidenceRequest};
/// Exact captured owner-private inventory command and original authenticated observation.
@@ -289,6 +293,26 @@ pub trait InventoryStore: WorkspaceStore {
) -> BoxFuture<'a, Result<StockEvidenceOutcome, OperationError>> {
Box::pin(async { Err(OperationError::UnsupportedOperation) })
}
+ /// Retains an obtained outer against actual original stock S/T2. The host
+ /// must verify exact containment and commit before any transport right.
+ /// Capture grants no dispatch permission; unsupported hosts refuse.
+ fn capture_stock_envelope<'a>(
+ &'a self,
+ _request: StockEnvelopeRequest,
+ _proof: AttachmentProof,
+ _candidate: &'a crate::command::PrivateEnvelopeCandidate,
+ ) -> BoxFuture<'a, Result<StockEnvelopeOutcome, OperationError>> {
+ Box::pin(async { Err(OperationError::UnsupportedOperation) })
+ }
+ /// Reads the exact original retained outer under current recovery access.
+ /// Absence is not permission to generate or dispatch a replacement.
+ fn stock_envelope(
+ &self,
+ _request: StockEnvelopeRequest,
+ _proof: AttachmentProof,
+ ) -> BoxFuture<'_, Result<Option<StockEnvelopeSource>, OperationError>> {
+ Box::pin(async { Err(OperationError::UnsupportedOperation) })
+ }
/// Prepares an original acceptance with complete atomic holds and the order
/// fence. Unsupported hosts execute no fallback or simulated stock effect.
fn prepare_stock_acceptance(
diff --git a/crates/storage/src/inventory/envelope.rs b/crates/storage/src/inventory/envelope.rs
@@ -0,0 +1,192 @@
+//! Original stock-envelope selectors and non-authoritative retained reports.
+use super::*;
+use core::{fmt, num::NonZeroU64};
+use radroots_domain::{EnvelopeEventId, PublicKey};
+use sha2::{Digest, Sha256};
+use zeroize::Zeroizing;
+
+/// Original recipient selectors and nullable observation; never stock authority.
+pub struct StockEnvelopeRequest {
+ binding: WorkspaceBinding,
+ minimum: InventoryCheckpointRef,
+ operation: OperationId,
+ digest: CommandDigest,
+ recipient: PublicKey,
+ observed: Option<NonZeroU64>,
+}
+impl StockEnvelopeRequest {
+ pub fn new(
+ binding: WorkspaceBinding,
+ minimum: InventoryCheckpointRef,
+ operation: OperationId,
+ digest: CommandDigest,
+ recipient: PublicKey,
+ observed: Option<NonZeroU64>,
+ ) -> Result<Self, OperationError> {
+ if binding.scope() != WorkspaceScope::SellerStockOwner {
+ return Err(OperationError::Unauthorized);
+ }
+ if minimum.authority() != binding.input().authority() {
+ return Err(crate::workspace::WorkspaceError::StaleAuthority.into());
+ }
+ Ok(Self {
+ binding,
+ minimum,
+ operation,
+ digest,
+ recipient,
+ observed,
+ })
+ }
+ pub const fn binding(&self) -> &WorkspaceBinding {
+ &self.binding
+ }
+ pub const fn minimum_checkpoint(&self) -> InventoryCheckpointRef {
+ self.minimum
+ }
+ pub const fn operation_id(&self) -> OperationId {
+ self.operation
+ }
+ pub const fn command_digest(&self) -> CommandDigest {
+ self.digest
+ }
+ pub const fn recipient(&self) -> PublicKey {
+ self.recipient
+ }
+ pub const fn observed_at_unix_ms(&self) -> Option<NonZeroU64> {
+ self.observed
+ }
+ pub fn attempt(&self) -> CommitAttempt {
+ CommitAttempt::new(
+ self.binding.input().workspace_id(),
+ self.operation,
+ self.digest,
+ None,
+ )
+ }
+}
+impl fmt::Debug for StockEnvelopeRequest {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("StockEnvelopeRequest(<redacted>)")
+ }
+}
+
+/// Actual capture metadata, independent of grant, dispatch or relay acceptance.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct StockEnvelopeReceipt {
+ attempt: CommitAttempt,
+ evidence: StockEvidenceReceipt,
+ installation: TransactionId,
+ event: EnvelopeEventId,
+ digest: [u8; 32],
+ checkpoint: InventoryCheckpointRef,
+ observed: Option<NonZeroU64>,
+}
+impl StockEnvelopeReceipt {
+ /// Checks scoped report shape only. The concrete host must authenticate
+ /// actual original S/T2, containment and confirmed capture atomically.
+ pub fn from_committed_store(
+ request: &StockEnvelopeRequest,
+ attempt: CommitAttempt,
+ evidence: StockEvidenceReceipt,
+ installation: TransactionId,
+ event: EnvelopeEventId,
+ digest: [u8; 32],
+ checkpoint: InventoryCheckpointRef,
+ ) -> Result<Self, OperationError> {
+ let source = evidence.attempt();
+ if attempt.transaction_id().is_none()
+ || attempt.workspace_id() != request.binding().input().workspace_id()
+ || attempt.operation_id() != request.operation_id()
+ || attempt.command_digest() != request.command_digest()
+ || source.workspace_id() != attempt.workspace_id()
+ || source.operation_id() != attempt.operation_id()
+ || source.command_digest() != attempt.command_digest()
+ || evidence.recipient() != request.recipient()
+ || checkpoint.authority() != request.binding().input().authority()
+ || checkpoint.revision().get() == 0
+ {
+ return Err(OperationError::RecoveryRequired);
+ }
+ Ok(Self {
+ attempt,
+ evidence,
+ installation,
+ event,
+ digest,
+ checkpoint,
+ observed: request.observed_at_unix_ms(),
+ })
+ }
+ pub const fn attempt(&self) -> CommitAttempt {
+ self.attempt
+ }
+ pub const fn evidence(&self) -> StockEvidenceReceipt {
+ self.evidence
+ }
+ pub const fn recipient(&self) -> PublicKey {
+ self.evidence.recipient()
+ }
+ pub const fn installation_transaction_id(&self) -> TransactionId {
+ self.installation
+ }
+ pub const fn event_id(&self) -> EnvelopeEventId {
+ self.event
+ }
+ pub const fn digest(&self) -> &[u8; 32] {
+ &self.digest
+ }
+ pub const fn checkpoint(&self) -> InventoryCheckpointRef {
+ self.checkpoint
+ }
+ pub const fn observed_at_unix_ms(&self) -> Option<NonZeroU64> {
+ self.observed
+ }
+}
+impl fmt::Debug for StockEnvelopeReceipt {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("StockEnvelopeReceipt(<redacted>)")
+ }
+}
+
+/// Exact retained outer. Construction verifies its carrier and reported digest,
+/// but grants no backend, inventory, dispatch or relay-acceptance authority.
+pub struct StockEnvelopeSource {
+ receipt: StockEnvelopeReceipt,
+ raw: Zeroizing<String>,
+}
+impl StockEnvelopeSource {
+ pub fn from_retained_wire(
+ receipt: StockEnvelopeReceipt,
+ raw: &str,
+ ) -> Result<Self, OperationError> {
+ let outer = crate::command::verified_private_outer(raw, receipt.recipient())?;
+ if outer.envelope().id().as_bytes() != receipt.event_id().as_bytes()
+ || <[u8; 32]>::from(Sha256::digest(raw.as_bytes())) != *receipt.digest()
+ {
+ return Err(OperationError::InvalidEvidence);
+ }
+ Ok(Self {
+ receipt,
+ raw: Zeroizing::new(raw.to_owned()),
+ })
+ }
+ pub const fn receipt(&self) -> StockEnvelopeReceipt {
+ self.receipt
+ }
+ pub fn with_json<T>(&self, use_json: impl FnOnce(&str) -> T) -> T {
+ use_json(&self.raw)
+ }
+}
+impl fmt::Debug for StockEnvelopeSource {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("StockEnvelopeSource(<redacted>)")
+ }
+}
+
+/// Confirmed original capture or its actual unresolved transaction identity.
+#[derive(Debug)]
+pub enum StockEnvelopeOutcome {
+ Committed(Box<StockEnvelopeReceipt>),
+ Unknown(CommitAttempt),
+}
diff --git a/crates/storage/tests/workspace.rs b/crates/storage/tests/workspace.rs
@@ -9,6 +9,9 @@ use radroots_storage::workspace::{
#[path = "workspace/inventory_abort.rs"]
mod inventory_abort;
#[cfg(feature = "protected_outbox")]
+#[path = "workspace/inventory_envelope.rs"]
+mod inventory_envelope;
+#[cfg(feature = "protected_outbox")]
#[path = "workspace/inventory_evidence.rs"]
mod inventory_evidence;
fn key() -> PublicKey {
diff --git a/crates/storage/tests/workspace/inventory_envelope.rs b/crates/storage/tests/workspace/inventory_envelope.rs
@@ -0,0 +1,161 @@
+//! Shape checks remain independent of concrete persistence and permission.
+use super::*;
+use radroots_domain::{
+ CommandDigest, EnvelopeEventId, OperationId, SigningAttemptId, TransactionId,
+};
+use radroots_storage::{
+ command::{CommitAttempt, OperationError},
+ inventory::{
+ InventoryCheckpointRef, StockEnvelopeReceipt, StockEnvelopeRequest, StockEvidenceReceipt,
+ },
+ workspace::WorkspaceScope,
+};
+
+fn binding(scope: WorkspaceScope) -> WorkspaceBinding {
+ WorkspaceBinding::from_authenticated_host(
+ input(),
+ scope,
+ ActorRef::new(key(), ActorRole::Seller, None, Some(input().grant_id())),
+ "synthetic",
+ Sequence::new(1).unwrap(),
+ UnixSeconds::new(200).unwrap(),
+ UnixSeconds::new(100).unwrap(),
+ )
+ .unwrap()
+}
+fn checkpoint(revision: u64) -> InventoryCheckpointRef {
+ InventoryCheckpointRef::from_host_metadata(
+ input().authority(),
+ Sequence::new(revision).unwrap(),
+ (revision != 0).then_some(CheckpointDigest::from_bytes([13; 32])),
+ )
+ .unwrap()
+}
+fn attempt(workspace: u8, operation: u8, digest: u8, committed: bool) -> CommitAttempt {
+ CommitAttempt::new(
+ WorkspaceId::from_bytes([workspace; 32]),
+ OperationId::from_bytes([operation; 32]),
+ CommandDigest::from_bytes([digest; 32]),
+ committed.then_some(TransactionId::from_bytes([11; 32])),
+ )
+}
+fn evidence(attempt: CommitAttempt, recipient: PublicKey) -> StockEvidenceReceipt {
+ StockEvidenceReceipt::from_committed_store(
+ attempt,
+ SigningAttemptId::from_bytes([9; 32]),
+ recipient,
+ [10; 32],
+ None,
+ )
+ .unwrap()
+}
+
+#[test]
+fn envelope_selector_refuses_foreign_authority_and_non_stock_scope_without_minting_a_transaction() {
+ let select = |scope, minimum| {
+ StockEnvelopeRequest::new(
+ binding(scope),
+ minimum,
+ OperationId::from_bytes([7; 32]),
+ CommandDigest::from_bytes([8; 32]),
+ key(),
+ None,
+ )
+ };
+ assert!(matches!(
+ select(WorkspaceScope::NewSellerOutbox, checkpoint(0)),
+ Err(OperationError::Unauthorized)
+ ));
+ let foreign = InventoryCheckpointRef::from_host_metadata(
+ AuthorityRef::new(
+ ExecutorId::from_bytes([99; 32]),
+ Generation::new(1).unwrap(),
+ ),
+ Sequence::new(0).unwrap(),
+ None,
+ )
+ .unwrap();
+ assert!(select(WorkspaceScope::SellerStockOwner, foreign).is_err());
+ let request = select(WorkspaceScope::SellerStockOwner, checkpoint(0)).unwrap();
+ assert_eq!(request.minimum_checkpoint(), checkpoint(0));
+ assert_eq!(request.attempt(), attempt(1, 7, 8, false));
+ assert!(request.observed_at_unix_ms().is_none());
+ assert_eq!(format!("{request:?}"), "StockEnvelopeRequest(<redacted>)");
+}
+
+#[test]
+fn envelope_report_rejects_mixed_originals_and_preserves_nullable_capture_observation() {
+ let original = attempt(1, 7, 8, true);
+ let source = evidence(original, key());
+ let peer =
+ PublicKey::from_hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5")
+ .unwrap();
+ for observed in [None, core::num::NonZeroU64::new(150000)] {
+ let request = StockEnvelopeRequest::new(
+ binding(WorkspaceScope::SellerStockOwner),
+ checkpoint(0),
+ original.operation_id(),
+ original.command_digest(),
+ key(),
+ observed,
+ )
+ .unwrap();
+ let report = |anchor, obtained, progress| {
+ StockEnvelopeReceipt::from_committed_store(
+ &request,
+ anchor,
+ obtained,
+ TransactionId::from_bytes([12; 32]),
+ EnvelopeEventId::from_bytes([14; 32]),
+ [15; 32],
+ progress,
+ )
+ };
+ for anchor in [
+ attempt(1, 7, 8, false),
+ attempt(99, 7, 8, true),
+ attempt(1, 99, 8, true),
+ attempt(1, 7, 99, true),
+ ] {
+ assert_eq!(
+ report(anchor, source, checkpoint(1)).unwrap_err(),
+ OperationError::RecoveryRequired
+ );
+ }
+ for obtained in [
+ evidence(attempt(99, 7, 8, true), key()),
+ evidence(attempt(1, 99, 8, true), key()),
+ evidence(attempt(1, 7, 99, true), key()),
+ evidence(original, peer),
+ ] {
+ assert_eq!(
+ report(original, obtained, checkpoint(1)).unwrap_err(),
+ OperationError::RecoveryRequired
+ );
+ }
+ assert!(report(original, source, checkpoint(0)).is_err());
+ let foreign = InventoryCheckpointRef::from_host_metadata(
+ AuthorityRef::new(
+ ExecutorId::from_bytes([99; 32]),
+ Generation::new(1).unwrap(),
+ ),
+ checkpoint(1).revision(),
+ checkpoint(1).head(),
+ )
+ .unwrap();
+ assert!(report(original, source, foreign).is_err());
+ let retained = report(original, source, checkpoint(1)).unwrap();
+ assert_eq!(retained.attempt(), original);
+ assert_eq!(retained.evidence(), source);
+ assert_eq!(retained.recipient(), key());
+ assert_eq!(
+ retained.installation_transaction_id(),
+ TransactionId::from_bytes([12; 32])
+ );
+ assert_eq!(retained.event_id(), EnvelopeEventId::from_bytes([14; 32]));
+ assert_eq!(retained.digest(), &[15; 32]);
+ assert_eq!(retained.checkpoint(), checkpoint(1));
+ assert_eq!(retained.observed_at_unix_ms(), observed);
+ assert_eq!(format!("{retained:?}"), "StockEnvelopeReceipt(<redacted>)");
+ }
+}
diff --git a/crates/storage_sqlite/tests/support/stock_envelope_port.rs b/crates/storage_sqlite/tests/support/stock_envelope_port.rs
@@ -0,0 +1,204 @@
+//! This checkpoint exports descriptors, not a stock-envelope backend.
+use super::*;
+use nostr::JsonUtil;
+use radroots_domain::{
+ CommandDigest, EnvelopeEventId, OperationId, Sequence, SigningAttemptId, TransactionId,
+};
+use radroots_storage::{
+ command::{CommitAttempt, OperationError, PrivateEnvelopeCandidate},
+ inventory::{
+ InventoryCheckpointRef, InventoryStore, StockEnvelopeReceipt, StockEnvelopeRequest,
+ StockEnvelopeSource, StockEvidenceReceipt,
+ },
+ workspace::WorkspaceBinding,
+};
+use radroots_storage_sqlite::workspace::{SellerStockConfig, StockEnrollment};
+use sha2::{Digest, Sha256};
+use sqlx::Connection;
+
+fn copy(proof: &AttachmentProof) -> AttachmentProof {
+ proof
+ .with_secret(|bytes| AttachmentProof::from_protected_input(bytes))
+ .unwrap()
+}
+fn minimum(input: &AttachmentInput, revision: u64) -> InventoryCheckpointRef {
+ InventoryCheckpointRef::from_host_metadata(
+ input.authority(),
+ Sequence::new(revision).unwrap(),
+ (revision != 0).then_some(CheckpointDigest::from_bytes([12; 32])),
+ )
+ .unwrap()
+}
+fn request(binding: &WorkspaceBinding) -> StockEnvelopeRequest {
+ StockEnvelopeRequest::new(
+ binding.clone(),
+ minimum(binding.input(), 0),
+ OperationId::from_bytes([80; 32]),
+ CommandDigest::from_bytes([81; 32]),
+ key(),
+ None,
+ )
+ .unwrap()
+}
+fn carrier() -> String {
+ // A genuine signed carrier with opaque synthetic content. Neither this
+ // signature nor the source model verifies a stock seal or mints authority.
+ let signer = nostr::Keys::new(nostr::SecretKey::from_slice(&[3; 32]).unwrap());
+ nostr::UnsignedEvent {
+ id: None,
+ pubkey: signer.public_key(),
+ created_at: nostr::Timestamp::from_secs(100),
+ kind: nostr::Kind::Custom(1059),
+ tags: nostr::Tags::from_list(vec![nostr::Tag::public_key(
+ nostr::PublicKey::from_slice(key().as_bytes()).unwrap(),
+ )]),
+ content: String::from("synthetic original carrier"),
+ }
+ .sign_with_keys(&signer)
+ .unwrap()
+ .as_json()
+}
+async fn stock(f: &Fixture) -> (NativeWorkspace, StockEnrollment, WorkspaceBinding) {
+ let enrollment = StockEnrollment::prepare(
+ SellerStockConfig::new(
+ key(),
+ key(),
+ "stock-envelope-boundary",
+ UnixSeconds::new(200).unwrap(),
+ )
+ .unwrap(),
+ f.clock.as_ref(),
+ )
+ .unwrap();
+ let store =
+ NativeWorkspace::initialize_seller_stock(&f.path, &enrollment, f.crypto(), f.clock.clone())
+ .await
+ .unwrap();
+ let binding = store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ (store, enrollment, binding)
+}
+
+#[tokio::test]
+async fn envelope_ports_explicitly_refuse_on_current_stock_and_ordinary_outbox_without_writes() {
+ let f = Fixture::new();
+ let (store, enrollment, binding) = stock(&f).await;
+ let outbox_fixture = Fixture::new();
+ let (outbox, _, _) = outbox_fixture.create().await;
+ let candidate = PrivateEnvelopeCandidate::from_obtained(key(), &carrier(), &[3; 32]).unwrap();
+ for port in [
+ &store as &dyn InventoryStore,
+ &outbox as &dyn InventoryStore,
+ ] {
+ assert!(matches!(
+ port.capture_stock_envelope(request(&binding), copy(enrollment.proof()), &candidate)
+ .await,
+ Err(OperationError::UnsupportedOperation)
+ ));
+ assert!(matches!(
+ port.stock_envelope(request(&binding), copy(enrollment.proof()))
+ .await,
+ Err(OperationError::UnsupportedOperation)
+ ));
+ }
+ // Current catalog and authoritative history remain unchanged by refusal.
+ let mut connection = sqlx::SqliteConnection::connect_with(
+ &sqlx::sqlite::SqliteConnectOptions::new()
+ .filename(f.path.join("stock_execution_v1.sqlite"))
+ .read_only(true),
+ )
+ .await
+ .unwrap();
+ let catalog: i64 = sqlx::query_scalar("PRAGMA user_version")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ let entries: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_operations")
+ .fetch_one(&mut connection)
+ .await
+ .unwrap();
+ assert_eq!(catalog, 15);
+ assert_eq!(entries, 0);
+ connection.close().await.unwrap();
+ assert!(
+ !outbox_fixture
+ .path
+ .join("stock_execution_v1.sqlite")
+ .exists()
+ );
+ store
+ .authenticate(enrollment.input().clone(), enrollment.proof())
+ .await
+ .unwrap();
+ outbox.close().await.unwrap();
+ store.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn reported_envelope_source_preserves_exact_carrier_and_refuses_tampered_or_mixed_reports() {
+ let f = Fixture::new();
+ let (store, _, binding) = stock(&f).await;
+ let selected = request(&binding);
+ let attempt = CommitAttempt::new(
+ selected.attempt().workspace_id(),
+ selected.operation_id(),
+ selected.command_digest(),
+ Some(TransactionId::from_bytes([82; 32])),
+ );
+ let evidence = StockEvidenceReceipt::from_committed_store(
+ attempt,
+ SigningAttemptId::from_bytes([83; 32]),
+ key(),
+ [84; 32],
+ None,
+ )
+ .unwrap();
+ let raw = carrier();
+ let event = nostr::Event::from_json(&raw).unwrap();
+ let id = EnvelopeEventId::from_bytes(event.id.to_bytes());
+ let digest = Sha256::digest(raw.as_bytes()).into();
+ let report = |id, digest| {
+ StockEnvelopeReceipt::from_committed_store(
+ &selected,
+ attempt,
+ evidence,
+ TransactionId::from_bytes([85; 32]),
+ id,
+ digest,
+ minimum(binding.input(), 1),
+ )
+ .unwrap()
+ };
+ // These public report constructors confer no persistence/stock permission.
+ let receipt = report(id, digest);
+ let source = StockEnvelopeSource::from_retained_wire(receipt, &raw).unwrap();
+ source.with_json(|retained| assert_eq!(retained.as_bytes(), raw.as_bytes()));
+ assert_eq!(source.receipt(), receipt);
+ assert_eq!(format!("{source:?}"), "StockEnvelopeSource(<redacted>)");
+ for (receipt, wire) in [
+ (
+ report(EnvelopeEventId::from_bytes([99; 32]), digest),
+ raw.clone(),
+ ),
+ (report(id, [99; 32]), raw.clone()),
+ (receipt, format!("{raw} ")),
+ (receipt, "x".repeat(65537)),
+ (receipt, "é".repeat(32769)),
+ ] {
+ assert!(matches!(
+ StockEnvelopeSource::from_retained_wire(receipt, &wire),
+ Err(OperationError::InvalidEvidence)
+ ));
+ }
+ for field in ["id", "sig"] {
+ let mut altered: serde_json::Value = serde_json::from_str(&raw).unwrap();
+ altered[field] = "0".repeat(if field == "id" { 64 } else { 128 }).into();
+ assert!(StockEnvelopeSource::from_retained_wire(receipt, &altered.to_string()).is_err());
+ }
+ let original = raw.clone();
+ drop(raw);
+ source.with_json(|retained| assert_eq!(retained, original));
+ store.close().await.unwrap();
+}
diff --git a/crates/storage_sqlite/tests/workspace_attachment.rs b/crates/storage_sqlite/tests/workspace_attachment.rs
@@ -544,6 +544,8 @@ async fn unsafe_links_permissions_and_schema_are_refused_without_repair() {
mod stock_abort_port;
#[path = "support/stock_authority.rs"]
mod stock_authority;
+#[path = "support/stock_envelope_port.rs"]
+mod stock_envelope_port;
#[path = "support/pool_creation.rs"]
mod pool_creation;