lib

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

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:
Mcontracts/api_baselines/radroots_storage.txt | 37+++++++++++++++++++++++++++++++++++++
Mcrates/storage/src/command.rs | 2++
Mcrates/storage/src/command/delivery.rs | 2+-
Mcrates/storage/src/inventory.rs | 24++++++++++++++++++++++++
Acrates/storage/src/inventory/envelope.rs | 192+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage/tests/workspace.rs | 3+++
Acrates/storage/tests/workspace/inventory_envelope.rs | 161+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/tests/support/stock_envelope_port.rs | 204+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/tests/workspace_attachment.rs | 2++
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;