commit f8fae3a381fa2bb3eab5f9bb4adb0e3eaa22281b parent a18c88450b34a5321aa09e2bc29da1bc2fc126b0 Author: triesap <tyson@radroots.org> Date: Thu, 29 Oct 2026 16:39:14 +0000 storage: persist explicit stock rewrap admissions and envelopes - add catalog 18 admissions and captures without changing retained formats - bind additional outers to original evidence and scope delivery observations - retain original credentials through faults and bound recovery index reads - verify native and Linux recovery, process boundaries, quotas, and API reports Diffstat:
68 files changed, 4138 insertions(+), 267 deletions(-)
diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -1409,6 +1409,10 @@ pub radroots_storage::inventory::StockEnvelopeOutcome::Unknown(radroots_storage: 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) +pub enum radroots_storage::inventory::StockRewrapOutcome +pub radroots_storage::inventory::StockRewrapOutcome::Claimed(alloc::boxed::Box<radroots_storage::inventory::StockRewrapAdmission>) +pub radroots_storage::inventory::StockRewrapOutcome::Retained(alloc::boxed::Box<radroots_storage::inventory::StockRewrapAdmission>) +pub radroots_storage::inventory::StockRewrapOutcome::Unknown(radroots_storage::command::CommitAttempt) pub struct radroots_storage::inventory::InventoryCheckpointRef impl radroots_storage::inventory::InventoryCheckpointRef pub const fn radroots_storage::inventory::InventoryCheckpointRef::authority(self) -> radroots_domain::context::AuthorityRef @@ -1539,6 +1543,7 @@ pub const fn radroots_storage::inventory::StockDeliveryRequest::expected_attempt pub const fn radroots_storage::inventory::StockDeliveryRequest::intent(&self) -> &radroots_storage::command::DeliveryIntent pub fn radroots_storage::inventory::StockDeliveryRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_storage::command::DeliveryIntent) -> core::result::Result<Self, radroots_storage::command::OperationError> pub const fn radroots_storage::inventory::StockDeliveryRequest::source(&self) -> &radroots_storage::inventory::StockEnvelopeRequest +pub fn radroots_storage::inventory::StockDeliveryRequest::with_envelope(self, radroots_domain::identifier::EnvelopeEventId) -> core::result::Result<Self, radroots_storage::command::OperationError> pub fn radroots_storage::inventory::StockDeliveryRequest::with_expected_attempt_count(self, u16) -> core::result::Result<Self, radroots_storage::command::OperationError> impl core::fmt::Debug for radroots_storage::inventory::StockDeliveryRequest pub fn radroots_storage::inventory::StockDeliveryRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -1548,7 +1553,9 @@ 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 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::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 @@ -1574,6 +1581,8 @@ pub fn radroots_storage::inventory::StockEnvelopeReceipt::from_committed_store(& 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 +pub const fn radroots_storage::inventory::StockEnvelopeReceipt::rewrap_admission_transaction_id(&self) -> core::option::Option<radroots_domain::identifier::TransactionId> +pub fn radroots_storage::inventory::StockEnvelopeReceipt::with_rewrap_admission(self, &radroots_storage::inventory::StockRewrapAdmission) -> core::result::Result<Self, radroots_storage::command::OperationError> 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 @@ -1581,11 +1590,13 @@ 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::envelope_event_id(&self) -> core::option::Option<radroots_domain::identifier::EnvelopeEventId> 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 +pub const fn radroots_storage::inventory::StockEnvelopeRequest::with_envelope(self, radroots_domain::identifier::EnvelopeEventId) -> Self 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 @@ -1626,25 +1637,62 @@ pub const fn radroots_storage::inventory::StockEvidenceSource::receipt(&self) -> pub fn radroots_storage::inventory::StockEvidenceSource::with_json<T>(&self, impl core::ops::function::FnOnce(&str) -> T) -> T impl core::fmt::Debug for radroots_storage::inventory::StockEvidenceSource pub fn radroots_storage::inventory::StockEvidenceSource::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::inventory::StockRewrapAdmission +impl radroots_storage::inventory::StockRewrapAdmission +pub const fn radroots_storage::inventory::StockRewrapAdmission::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub const fn radroots_storage::inventory::StockRewrapAdmission::expires_at(&self) -> radroots_domain::context::UnixSeconds +pub fn radroots_storage::inventory::StockRewrapAdmission::from_store_report(&radroots_storage::inventory::StockRewrapRequest, radroots_storage::inventory::StockEnvelopeReceipt, radroots_domain::identifier::TransactionId, radroots_domain::context::UnixSeconds, radroots_domain::context::UnixSeconds, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::inventory::StockRewrapAdmission::original(&self) -> radroots_storage::inventory::StockEnvelopeReceipt +pub const fn radroots_storage::inventory::StockRewrapAdmission::prepared_at(&self) -> radroots_domain::context::UnixSeconds +pub const fn radroots_storage::inventory::StockRewrapAdmission::rewrap_id(&self) -> radroots_domain::identifier::OperationId +pub const fn radroots_storage::inventory::StockRewrapAdmission::transaction_id(&self) -> radroots_domain::identifier::TransactionId +impl core::fmt::Debug for radroots_storage::inventory::StockRewrapAdmission +pub fn radroots_storage::inventory::StockRewrapAdmission::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::inventory::StockRewrapPage +impl radroots_storage::inventory::StockRewrapPage +pub const fn radroots_storage::inventory::StockRewrapPage::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub fn radroots_storage::inventory::StockRewrapPage::entries(&self) -> &[radroots_storage::inventory::StockRewrapState] +pub fn radroots_storage::inventory::StockRewrapPage::from_store_report(&radroots_storage::inventory::StockEnvelopeRequest, alloc::vec::Vec<radroots_storage::inventory::StockRewrapState>, bool, radroots_storage::inventory::InventoryCheckpointRef) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::inventory::StockRewrapPage::next_after(&self) -> core::option::Option<radroots_domain::context::Sequence> +pub struct radroots_storage::inventory::StockRewrapRequest +impl radroots_storage::inventory::StockRewrapRequest +pub fn radroots_storage::inventory::StockRewrapRequest::attempt(&self) -> radroots_storage::command::CommitAttempt +pub const fn radroots_storage::inventory::StockRewrapRequest::new(radroots_storage::inventory::StockEnvelopeRequest, radroots_domain::identifier::OperationId) -> Self +pub const fn radroots_storage::inventory::StockRewrapRequest::rewrap_id(&self) -> radroots_domain::identifier::OperationId +pub const fn radroots_storage::inventory::StockRewrapRequest::source(&self) -> &radroots_storage::inventory::StockEnvelopeRequest +pub fn radroots_storage::inventory::StockRewrapRequest::with_envelope(self, radroots_domain::identifier::EnvelopeEventId) -> Self +impl core::fmt::Debug for radroots_storage::inventory::StockRewrapRequest +pub fn radroots_storage::inventory::StockRewrapRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::inventory::StockRewrapState +impl radroots_storage::inventory::StockRewrapState +pub const fn radroots_storage::inventory::StockRewrapState::admission(&self) -> radroots_storage::inventory::StockRewrapAdmission +pub const fn radroots_storage::inventory::StockRewrapState::envelope(&self) -> core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt> +pub fn radroots_storage::inventory::StockRewrapState::from_store_report(radroots_storage::inventory::StockRewrapAdmission, core::option::Option<radroots_storage::inventory::StockEnvelopeReceipt>) -> core::result::Result<Self, radroots_storage::command::OperationError> pub trait radroots_storage::inventory::InventoryStore: radroots_storage::workspace::WorkspaceStore pub fn radroots_storage::inventory::InventoryStore::abort_proven_unissued(&self, radroots_storage::inventory::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockAbortOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::capture_stock_envelope<'a>(&'a self, radroots_storage::inventory::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::capture_stock_evidence<'a>(&'a self, &'a radroots_storage::inventory::StockEvidenceRequest, &'a radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEvidenceOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::capture_stock_rewrap<'a>(&'a self, radroots_storage::inventory::StockRewrapRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::execute_inventory(&self, radroots_storage::inventory::InventoryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::InventoryOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::inventory_operation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::InventoryReceipt>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::option_mapping(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>> 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::prepare_stock_delivery_attempt(&self, radroots_storage::inventory::StockDeliveryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockDeliveryAttemptOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::prepare_stock_rewrap(&self, radroots_storage::inventory::StockRewrapRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockRewrapOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::reconcile_stock_delivery_observation<'a>(&'a self, &'a radroots_storage::workspace::WorkspaceBinding, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::inventory::StockDeliveryObservation) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockDeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::reconcile_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::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::reconcile_stock_rewrap<'a>(&'a self, radroots_storage::inventory::StockRewrapRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockEnvelopeOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::reconcile_stock_rewrap_admission(&self, radroots_storage::inventory::StockRewrapRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<(), radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::record_stock_delivery_observation<'a>(&'a self, &'a radroots_storage::workspace::WorkspaceBinding, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::inventory::StockDeliveryObservation) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::StockDeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::stock_delivery_attempt(&self, radroots_storage::inventory::StockEnvelopeRequest, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::StockDeliveryAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::stock_delivery_observations(&self, radroots_storage::inventory::StockEnvelopeRequest, core::option::Option<radroots_domain::context::Sequence>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockDeliveryObservationPage, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::stock_delivery_summary(&self, radroots_storage::inventory::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockDeliverySummary, 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 fn radroots_storage::inventory::InventoryStore::stock_rewrap_attempt(&self, radroots_storage::inventory::StockRewrapRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::StockRewrapState>, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::stock_rewraps(&self, radroots_storage::inventory::StockEnvelopeRequest, core::option::Option<radroots_domain::context::Sequence>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockRewrapPage, radroots_storage::command::OperationError>> pub mod radroots_storage::journal pub use radroots_storage::journal::BoxFuture pub use radroots_storage::journal::EventId diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -499,21 +499,27 @@ impl radroots_storage::inventory::InventoryStore for radroots_storage_sqlite::wo pub fn radroots_storage_sqlite::workspace::NativeWorkspace::abort_proven_unissued(&self, radroots_storage::inventory::abort::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::abort::StockAbortOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_stock_envelope<'a>(&'a self, radroots_storage::inventory::envelope::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::delivery::private::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::envelope::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_stock_evidence<'a>(&'a self, &'a radroots_storage::inventory::evidence::StockEvidenceRequest, &'a radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::evidence::StockEvidenceOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_stock_rewrap<'a>(&'a self, radroots_storage::inventory::rewrap::StockRewrapRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::delivery::private::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::envelope::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::execute_inventory(&self, radroots_storage::inventory::InventoryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::InventoryOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::inventory_operation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::InventoryReceipt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::option_mapping(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::prepare_stock_acceptance(&self, radroots_storage::inventory::acceptance::StockAcceptanceRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::acceptance::StockAcceptanceOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::prepare_stock_delivery_attempt(&self, radroots_storage::inventory::delivery::StockDeliveryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::delivery::StockDeliveryAttemptOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::prepare_stock_rewrap(&self, radroots_storage::inventory::rewrap::StockRewrapRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::rewrap::StockRewrapOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_stock_delivery_observation<'a>(&'a self, &'a radroots_storage::workspace::WorkspaceBinding, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::inventory::delivery::StockDeliveryObservation) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::delivery::StockDeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_stock_envelope<'a>(&'a self, radroots_storage::inventory::envelope::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::delivery::private::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::envelope::StockEnvelopeOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_stock_evidence<'a>(&'a self, &'a radroots_storage::inventory::evidence::StockEvidenceRequest, &'a radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::evidence::StockEvidenceOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_stock_rewrap<'a>(&'a self, radroots_storage::inventory::rewrap::StockRewrapRequest, radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::delivery::private::PrivateEnvelopeCandidate) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::envelope::StockEnvelopeOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_stock_rewrap_admission(&self, radroots_storage::inventory::rewrap::StockRewrapRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<(), radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::record_stock_delivery_observation<'a>(&'a self, &'a radroots_storage::workspace::WorkspaceBinding, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::inventory::delivery::StockDeliveryObservation) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::inventory::delivery::StockDeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_delivery_attempt(&self, radroots_storage::inventory::envelope::StockEnvelopeRequest, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::delivery::StockDeliveryAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_delivery_observations(&self, radroots_storage::inventory::envelope::StockEnvelopeRequest, core::option::Option<radroots_domain::context::Sequence>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::delivery_state::StockDeliveryObservationPage, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_delivery_summary(&self, radroots_storage::inventory::envelope::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::delivery_state::StockDeliverySummary, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_envelope(&self, radroots_storage::inventory::envelope::StockEnvelopeRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::envelope::StockEnvelopeSource>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_preparation_abort(&self, radroots_storage::inventory::abort::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::abort::StockAbortReceipt>, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_rewrap_attempt(&self, radroots_storage::inventory::rewrap::StockRewrapRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::rewrap::StockRewrapState>, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_rewraps(&self, radroots_storage::inventory::envelope::StockEnvelopeRequest, core::option::Option<radroots_domain::context::Sequence>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::rewrap::StockRewrapPage, radroots_storage::command::OperationError>> impl radroots_storage::workspace::WorkspaceStore for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::close_workspace(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<(), radroots_storage::workspace::WorkspaceError>> diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -82,7 +82,7 @@ "adapter": "radroots_nostr.signing.LocalSigner", "native_authorizer": "NativeWorkspace.authorize_stock_exact_replay", "captured_replay": "local_replay_safe", - "native_catalog": 17, + "native_catalog": 18, "worker_charge_bytes": 1048576, "existing_protected_claim_required": true, "current_execute_consent_required": true, @@ -111,7 +111,7 @@ "scope": "seller_stock_owner", "database": "stock_execution_v1.sqlite", "lock": ".stock_execution_v1.lock", - "schema_version": 17, + "schema_version": 18, "retained_enrollment_versions": [ 1 ], @@ -130,9 +130,10 @@ 13, 14, 15, - 16 + 16, + 17 ], - "authority_payload_schema": "radroots.seller_stock.authority.v17", + "authority_payload_schema": "radroots.seller_stock.authority.v18", "public_source_payload_schemas": [ "radroots.seller_stock.public_source_event.v1", "radroots.seller_stock.public_source_head.v1", @@ -397,7 +398,8 @@ "claimed_cleanup_catalogs": [ 15, 16, - 17 + 17, + 18 ], "untracked_claimed_catalogs": [ 13, @@ -417,7 +419,8 @@ "payload_prefix_bytes": 213, "supported_catalogs": [ 16, - 17 + 17, + 18 ], "retained_unsupported_catalogs": [ 1, @@ -456,7 +459,8 @@ }, "delivery": { "supported_catalogs": [ - 17 + 17, + 18 ], "retained_unsupported_catalogs": [ 1, @@ -523,6 +527,66 @@ "unbounded_attempt_or_observation_collections": false, "physical_stock_effect": false, "transport_inside_sql": false + }, + "rewrapping": { + "journal_family": 14, + "payload_version": 1, + "payload_prefix_bytes": 117, + "supported_catalogs": [ + 18 + ], + "retained_unsupported_catalogs": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "raw_max_bytes": 65536, + "worker_charge_bytes": 1048576, + "additional_envelopes_per_recipient_max": 192, + "descriptor_page_max": 16, + "capture_port": "InventoryStore.capture_stock_rewrap", + "recovery_port": "InventoryStore.reconcile_stock_rewrap", + "query_port": "InventoryStore.stock_envelope", + "page_port": "InventoryStore.stock_rewraps", + "original_f10_and_same_s_t2_required": true, + "default_selection_is_original": true, + "new_envelope_selection_explicit": true, + "first_policy_source_bound": true, + "transport_counters_cumulative": true, + "outcomes_scoped_to_exact_envelope": true, + "natural_index_transaction_witness_required": true, + "existing_bytes_may_be_replaced": false, + "original_capture_requires_live_clock_or_grant": false, + "capture_or_query_grants_dispatch": false, + "physical_stock_effect": false, + "temporary_key_retained": false, + "provider_io_inside_sql": false, + "admission_journal_family": 13, + "admission_payload_bytes": 248, + "admission_window_seconds_max": 30, + "admission_port": "InventoryStore.prepare_stock_rewrap", + "admission_recovery_port": "InventoryStore.reconcile_stock_rewrap_admission", + "admission_query_port": "InventoryStore.stock_rewrap_attempt", + "explicit_request_id_required": true, + "newly_confirmed_admission_before_wrapping": true, + "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 } }, "provenance": { diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs @@ -13,6 +13,7 @@ mod delivery; mod delivery_state; mod envelope; mod evidence; +mod rewrap; pub use abort::{StockAbortOutcome, StockAbortReceipt, StockAbortRequest}; pub use acceptance::{StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest}; pub use delivery::{ @@ -28,6 +29,9 @@ pub use envelope::{ pub use evidence::{ StockEvidenceOutcome, StockEvidenceReceipt, StockEvidenceRequest, StockEvidenceSource, }; +pub use rewrap::{ + StockRewrapAdmission, StockRewrapOutcome, StockRewrapPage, StockRewrapRequest, StockRewrapState, +}; /// Exact captured owner-private inventory command and original authenticated observation. pub struct InventoryRequest { @@ -315,6 +319,64 @@ pub trait InventoryStore: WorkspaceStore { ) -> BoxFuture<'a, Result<StockEnvelopeOutcome, OperationError>> { Box::pin(async { Err(OperationError::UnsupportedOperation) }) } + /// Confirms one explicit wrapping admission before invoking wrapping. + /// Only a qualified host's newly confirmed claim qualifies one invocation; + /// existing and uncertain admissions never qualify another invocation. + fn prepare_stock_rewrap( + &self, + _request: StockRewrapRequest, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<StockRewrapOutcome, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Queries an admission and any actual captured envelope without qualifying + /// another wrapping invocation. Missing bytes cannot authorize regeneration. + fn stock_rewrap_attempt( + &self, + _request: StockRewrapRequest, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<StockRewrapState>, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Repairs the original caller's retained writer state without a fresh + /// clock. Returns no history, wrapping permit or dispatch permission; + /// subsequent status reads still require current recovery access. + fn reconcile_stock_rewrap_admission( + &self, + _request: StockRewrapRequest, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<(), OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Appends an obtained additional outer to its actual original admission. + fn capture_stock_rewrap<'a>( + &'a self, + _request: StockRewrapRequest, + _proof: AttachmentProof, + _candidate: &'a crate::command::PrivateEnvelopeCandidate, + ) -> BoxFuture<'a, Result<StockEnvelopeOutcome, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Reconciles the original additional outer on its retained connection + /// owner. This never obtains new wrapping material or renews permission. + fn reconcile_stock_rewrap<'a>( + &'a self, + _request: StockRewrapRequest, + _proof: AttachmentProof, + _candidate: &'a crate::command::PrivateEnvelopeCandidate, + ) -> BoxFuture<'a, Result<StockEnvelopeOutcome, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Pages additional-envelope descriptors under current recovery access. + /// Queries retain original identities without loading every raw envelope. + fn stock_rewraps( + &self, + _request: StockEnvelopeRequest, + _after: Option<radroots_domain::Sequence>, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<StockRewrapPage, 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( diff --git a/crates/storage/src/inventory/delivery.rs b/crates/storage/src/inventory/delivery.rs @@ -51,6 +51,15 @@ impl StockDeliveryRequest { pub const fn expected_attempt_count(&self) -> Option<u16> { self.expected_attempts } + /// Selects exact retained bytes for this intent without obtaining another + /// outer or renewing the recipient's cumulative invocation budget. + pub fn with_envelope(mut self, event: EnvelopeEventId) -> Result<Self, OperationError> { + if event != self.intent.event_id() { + return Err(OperationError::InvalidCommand); + } + self.source = self.source.with_envelope(event); + Ok(self) + } pub const fn source(&self) -> &StockEnvelopeRequest { &self.source } diff --git a/crates/storage/src/inventory/delivery_state.rs b/crates/storage/src/inventory/delivery_state.rs @@ -73,6 +73,7 @@ impl fmt::Debug for StockDeliveryTargetProgress { pub struct StockDeliverySummary { source: Option<StockEnvelopeReceipt>, first: Option<DeliveryIntent>, + policy_source: Option<StockEnvelopeReceipt>, attempts: u16, targets: Box<[StockDeliveryTargetProgress]>, checkpoint: InventoryCheckpointRef, @@ -88,6 +89,29 @@ impl StockDeliverySummary { targets: Vec<StockDeliveryTargetProgress>, checkpoint: InventoryCheckpointRef, ) -> Result<Self, OperationError> { + let policy_source = first.as_ref().and(source); + Self::from_store_report_with_policy_source( + request, + source, + policy_source, + first, + attempts, + targets, + checkpoint, + ) + } + /// 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. + pub fn from_store_report_with_policy_source( + request: &StockEnvelopeRequest, + source: Option<StockEnvelopeReceipt>, + policy_source: Option<StockEnvelopeReceipt>, + first: Option<DeliveryIntent>, + attempts: u16, + targets: Vec<StockDeliveryTargetProgress>, + checkpoint: InventoryCheckpointRef, + ) -> Result<Self, OperationError> { if checkpoint.authority() != request.binding().input().authority() || checkpoint.revision().get() == 0 || attempts > 16 * 12 @@ -103,6 +127,26 @@ impl StockDeliverySummary { || source.recipient() != request.recipient() || source.checkpoint().authority() != checkpoint.authority() || source.checkpoint().revision() > checkpoint.revision() + || request + .envelope_event_id() + .is_some_and(|event| event != source.event_id()) + { + return Err(OperationError::RecoveryRequired); + } + } + if let Some(policy_source) = policy_source { + let selected = source.ok_or(OperationError::RecoveryRequired)?; + let policy_attempt = policy_source.attempt(); + let selected_attempt = selected.attempt(); + if policy_source.evidence() != selected.evidence() + || policy_source.installation_transaction_id() + != selected.installation_transaction_id() + || policy_attempt.workspace_id() != selected_attempt.workspace_id() + || policy_attempt.operation_id() != selected_attempt.operation_id() + || policy_attempt.command_digest() != selected_attempt.command_digest() + || policy_source.checkpoint().authority() != checkpoint.authority() + || policy_source.checkpoint().revision() > checkpoint.revision() + || first.is_none() { return Err(OperationError::RecoveryRequired); } @@ -114,7 +158,8 @@ impl StockDeliverySummary { Some(intent) if attempts == 0 || intent.role() != ArtifactRole::GiftWrap - || source.is_none_or(|source| source.event_id() != intent.event_id()) + || policy_source + .is_none_or(|source| source.event_id() != intent.event_id()) || intent .targets() .targets() @@ -137,6 +182,7 @@ impl StockDeliverySummary { Ok(Self { source, first, + policy_source, attempts, targets: targets.into_boxed_slice(), checkpoint, @@ -148,6 +194,11 @@ impl StockDeliverySummary { pub const fn original_intent(&self) -> Option<&DeliveryIntent> { self.first.as_ref() } + /// Source of the first immutable target policy, which may differ from the + /// explicitly selected rewrapped envelope. + pub const fn publication_policy_source(&self) -> Option<StockEnvelopeReceipt> { + self.policy_source + } pub const fn attempt_count(&self) -> u16 { self.attempts } @@ -211,6 +262,9 @@ impl StockDeliveryObservationPage { || original.recipient() != request.recipient() || entry.checkpoint().authority() != checkpoint.authority() || entry.checkpoint().revision() > checkpoint.revision() + || request + .envelope_event_id() + .is_some_and(|event| event != original.event_id()) { return Err(OperationError::RecoveryRequired); } diff --git a/crates/storage/src/inventory/envelope.rs b/crates/storage/src/inventory/envelope.rs @@ -13,6 +13,7 @@ pub struct StockEnvelopeRequest { digest: CommandDigest, recipient: PublicKey, observed: Option<NonZeroU64>, + envelope: Option<EnvelopeEventId>, } impl StockEnvelopeRequest { pub fn new( @@ -36,8 +37,18 @@ impl StockEnvelopeRequest { digest, recipient, observed, + envelope: None, }) } + /// Selects an exact retained outer. This metadata grants neither wrapping + /// nor transport permission. Omission keeps original-envelope semantics. + pub const fn with_envelope(mut self, event: EnvelopeEventId) -> Self { + self.envelope = Some(event); + self + } + pub const fn envelope_event_id(&self) -> Option<EnvelopeEventId> { + self.envelope + } pub const fn binding(&self) -> &WorkspaceBinding { &self.binding } @@ -81,6 +92,7 @@ pub struct StockEnvelopeReceipt { digest: [u8; 32], checkpoint: InventoryCheckpointRef, observed: Option<NonZeroU64>, + rewrap_admission: Option<TransactionId>, } impl StockEnvelopeReceipt { /// Checks scoped report shape only. The concrete host must authenticate @@ -105,6 +117,9 @@ impl StockEnvelopeReceipt { || evidence.recipient() != request.recipient() || checkpoint.authority() != request.binding().input().authority() || checkpoint.revision().get() == 0 + || request + .envelope_event_id() + .is_some_and(|selected| selected != event) { return Err(OperationError::RecoveryRequired); } @@ -116,6 +131,7 @@ impl StockEnvelopeReceipt { digest, checkpoint, observed: request.observed_at_unix_ms(), + rewrap_admission: None, }) } pub const fn attempt(&self) -> CommitAttempt { @@ -142,6 +158,31 @@ impl StockEnvelopeReceipt { pub const fn observed_at_unix_ms(&self) -> Option<NonZeroU64> { self.observed } + pub const fn rewrap_admission_transaction_id(&self) -> Option<TransactionId> { + self.rewrap_admission + } + /// Links a reported additional outer to its original wrapping admission. + /// Only shape is checked; the qualified host authenticates actual F13/F14. + pub fn with_rewrap_admission( + mut self, + admission: &super::StockRewrapAdmission, + ) -> Result<Self, OperationError> { + let original = admission.original(); + if self.evidence != original.evidence() + || self.installation != original.installation_transaction_id() + || self.event == original.event_id() + || self.checkpoint.authority() != admission.checkpoint().authority() + || self.checkpoint.revision() <= admission.checkpoint().revision() + || self.attempt.transaction_id() == Some(admission.transaction_id()) + || self + .rewrap_admission + .is_some_and(|transaction| transaction != admission.transaction_id()) + { + return Err(OperationError::RecoveryRequired); + } + self.rewrap_admission = Some(admission.transaction_id()); + Ok(self) + } } impl fmt::Debug for StockEnvelopeReceipt { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { diff --git a/crates/storage/src/inventory/rewrap.rs b/crates/storage/src/inventory/rewrap.rs @@ -0,0 +1,216 @@ +//! Explicit rewrap invocation identity and non-authoritative recovery reports. +use super::*; +use core::fmt; +use radroots_domain::{Sequence, UnixSeconds}; + +pub struct StockRewrapRequest { + source: StockEnvelopeRequest, + id: OperationId, +} +impl StockRewrapRequest { + pub const fn new(source: StockEnvelopeRequest, id: OperationId) -> Self { + Self { source, id } + } + pub const fn source(&self) -> &StockEnvelopeRequest { + &self.source + } + pub const fn rewrap_id(&self) -> OperationId { + self.id + } + pub fn with_envelope(mut self, event: radroots_domain::EnvelopeEventId) -> Self { + self.source = self.source.with_envelope(event); + self + } + pub fn attempt(&self) -> CommitAttempt { + self.source.attempt() + } +} +impl fmt::Debug for StockRewrapRequest { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("StockRewrapRequest(<redacted>)") + } +} + +/// Original confirmed wrapping admission. Only a qualified concrete owner's +/// newly confirmed Claimed outcome can qualify an invocation. This report, +/// an existing admission or an uncertain commit cannot do so. +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct StockRewrapAdmission { + id: OperationId, + original: StockEnvelopeReceipt, + transaction: TransactionId, + at: UnixSeconds, + expires: UnixSeconds, + checkpoint: InventoryCheckpointRef, +} +impl StockRewrapAdmission { + pub fn from_store_report( + request: &StockRewrapRequest, + original: StockEnvelopeReceipt, + transaction: TransactionId, + at: UnixSeconds, + expires: UnixSeconds, + checkpoint: InventoryCheckpointRef, + ) -> Result<Self, OperationError> { + let source = request.source(); + let attempt = original.attempt(); + if source.envelope_event_id().is_some() + || original.rewrap_admission_transaction_id().is_some() + || attempt.workspace_id() != source.binding().input().workspace_id() + || attempt.operation_id() != source.operation_id() + || attempt.command_digest() != source.command_digest() + || original.recipient() != source.recipient() + || at.get() == 0 + || expires <= at + || expires + .get() + .checked_sub(at.get()) + .is_none_or(|seconds| seconds > 30) + || checkpoint.authority() != source.binding().input().authority() + || original.checkpoint().authority() != checkpoint.authority() + || checkpoint.revision() <= original.checkpoint().revision() + { + return Err(OperationError::RecoveryRequired); + } + Ok(Self { + id: request.id, + original, + transaction, + at, + expires, + checkpoint, + }) + } + pub const fn rewrap_id(&self) -> OperationId { + self.id + } + pub const fn original(&self) -> StockEnvelopeReceipt { + self.original + } + pub const fn transaction_id(&self) -> TransactionId { + self.transaction + } + pub const fn prepared_at(&self) -> UnixSeconds { + self.at + } + pub const fn expires_at(&self) -> UnixSeconds { + self.expires + } + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } +} +impl fmt::Debug for StockRewrapAdmission { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("StockRewrapAdmission(<redacted>)") + } +} +#[derive(Debug)] +pub enum StockRewrapOutcome { + Claimed(Box<StockRewrapAdmission>), + Retained(Box<StockRewrapAdmission>), + Unknown(CommitAttempt), +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct StockRewrapState { + admission: StockRewrapAdmission, + envelope: Option<StockEnvelopeReceipt>, +} +impl StockRewrapState { + /// Validates shape only. The host must authenticate the actual F13/F14 + /// link. Missing bytes convey no proof of nonissuance or new wrapping right. + pub fn from_store_report( + admission: StockRewrapAdmission, + envelope: Option<StockEnvelopeReceipt>, + ) -> Result<Self, OperationError> { + if let Some(envelope) = envelope + && (envelope.rewrap_admission_transaction_id() != Some(admission.transaction_id()) + || envelope.evidence() != admission.original().evidence() + || envelope.installation_transaction_id() + != admission.original().installation_transaction_id() + || envelope.checkpoint().authority() != admission.checkpoint().authority() + || envelope.checkpoint().revision() <= admission.checkpoint().revision()) + { + return Err(OperationError::RecoveryRequired); + } + Ok(Self { + admission, + envelope, + }) + } + pub const fn admission(&self) -> StockRewrapAdmission { + self.admission + } + pub const fn envelope(&self) -> Option<StockEnvelopeReceipt> { + self.envelope + } +} + +#[derive(Debug)] +pub struct StockRewrapPage { + entries: Box<[StockRewrapState]>, + next: Option<Sequence>, + checkpoint: InventoryCheckpointRef, +} +impl StockRewrapPage { + pub fn from_store_report( + request: &StockEnvelopeRequest, + entries: Vec<StockRewrapState>, + more: bool, + checkpoint: InventoryCheckpointRef, + ) -> Result<Self, OperationError> { + if entries.len() > 16 + || (more && entries.len() != 16) + || request.envelope_event_id().is_some() + || checkpoint.authority() != request.binding().input().authority() + || checkpoint.revision() < request.minimum_checkpoint().revision() + || entries.windows(2).any(|pair| { + pair[0].admission.checkpoint().revision() + >= pair[1].admission.checkpoint().revision() + }) + { + return Err(OperationError::RecoveryRequired); + } + for (index, state) in entries.iter().enumerate() { + let original = state.admission.original(); + if original.attempt().workspace_id() != request.binding().input().workspace_id() + || original.attempt().operation_id() != request.operation_id() + || original.attempt().command_digest() != request.command_digest() + || original.recipient() != request.recipient() + || state.admission.checkpoint().authority() != checkpoint.authority() + || state.admission.checkpoint().revision() > checkpoint.revision() + || state.envelope.is_some_and(|envelope| { + envelope.checkpoint().revision() > checkpoint.revision() + }) + || entries[..index].iter().any(|prior| { + prior.admission.rewrap_id() == state.admission.rewrap_id() + || prior.admission.transaction_id() == state.admission.transaction_id() + }) + { + return Err(OperationError::RecoveryRequired); + } + } + let next = if more { + entries + .last() + .map(|state| state.admission.checkpoint().revision()) + } else { + None + }; + Ok(Self { + entries: entries.into_boxed_slice(), + next, + checkpoint, + }) + } + pub fn entries(&self) -> &[StockRewrapState] { + &self.entries + } + pub const fn next_after(&self) -> Option<Sequence> { + self.next + } + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } +} diff --git a/crates/storage/tests/workspace/inventory_delivery.rs b/crates/storage/tests/workspace/inventory_delivery.rs @@ -4,7 +4,8 @@ use radroots_storage::{ command::{DeliveryIntent, DeliveryObservationKind}, inventory::{ StockDeliveryObservationPage, StockDeliveryRequest, StockDeliverySummary, - StockDeliveryTargetProgress, + StockDeliveryTargetProgress, StockRewrapAdmission, StockRewrapPage, StockRewrapRequest, + StockRewrapState, }, }; use radroots_transport::{ @@ -48,6 +49,185 @@ fn fixture() -> (StockEnvelopeRequest, StockEnvelopeReceipt, DeliveryIntent) { .unwrap(); (request, source, intent) } +fn admission( + request: &StockEnvelopeRequest, + original: StockEnvelopeReceipt, + index: u8, +) -> StockRewrapAdmission { + StockRewrapAdmission::from_store_report( + &StockRewrapRequest::new( + StockEnvelopeRequest::new( + request.binding().clone(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), + request.recipient(), + None, + ) + .unwrap(), + OperationId::from_bytes([index + 1; 32]), + ), + original, + TransactionId::from_bytes([index + 128; 32]), + radroots_domain::UnixSeconds::new(150).unwrap(), + radroots_domain::UnixSeconds::new(180).unwrap(), + checkpoint(u64::from(index) + 2), + ) + .unwrap() +} +fn rewrapped( + request: &StockEnvelopeRequest, + original: StockEnvelopeReceipt, + index: u8, +) -> StockEnvelopeReceipt { + let event = EnvelopeEventId::from_bytes([index + 64; 32]); + let selected = StockEnvelopeRequest::new( + request.binding().clone(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), + request.recipient(), + None, + ) + .unwrap() + .with_envelope(event); + StockEnvelopeReceipt::from_committed_store( + &selected, + radroots_storage::command::CommitAttempt::new( + original.attempt().workspace_id(), + original.attempt().operation_id(), + original.attempt().command_digest(), + Some(TransactionId::from_bytes([index + 32; 32])), + ), + original.evidence(), + original.installation_transaction_id(), + event, + [index + 96; 32], + checkpoint(u64::from(index) + 3), + ) + .unwrap() + .with_rewrap_admission(&admission(request, original, index)) + .unwrap() +} + +#[test] +fn selected_envelope_retains_a_separate_first_policy_source_without_weakening_original_reports() { + 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()); + assert!( + StockDeliverySummary::from_store_report( + &selected, + Some(new), + Some(intent.clone()), + 1, + progress(&intent, &[false, false]), + checkpoint(4) + ) + .is_err() + ); + let summary = StockDeliverySummary::from_store_report_with_policy_source( + &selected, + Some(new), + Some(original), + Some(intent.clone()), + 1, + progress(&intent, &[false, false]), + checkpoint(4), + ) + .unwrap(); + assert_eq!(summary.source(), Some(new)); + assert_eq!(summary.publication_policy_source(), Some(original)); + assert_eq!(summary.original_intent(), Some(&intent)); + assert!(!summary.acceptance_satisfied().unwrap()); + let wrong_policy = rewrapped(&request, original, 2); + assert!( + StockDeliverySummary::from_store_report_with_policy_source( + &selected, + Some(new), + Some(wrong_policy), + Some(intent.clone()), + 1, + progress(&intent, &[false, false]), + checkpoint(5) + ) + .is_err() + ); + assert!( + StockDeliveryRequest::new( + request.binding().clone(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), + request.recipient(), + intent + ) + .unwrap() + .with_envelope(new.event_id()) + .is_err() + ); +} + +#[test] +fn additional_envelope_pages_reject_duplicate_identities_oversized_pages_and_false_cursors() { + let (request, original, _) = fixture(); + let entries = (0..16) + .map(|index| { + StockRewrapState::from_store_report( + admission(&request, original, index), + Some(rewrapped(&request, original, index)), + ) + .unwrap() + }) + .collect::<Vec<_>>(); + let cursor = entries[15].admission().checkpoint().revision(); + let page = StockRewrapPage::from_store_report(&request, entries.clone(), true, checkpoint(18)) + .unwrap(); + assert_eq!(page.entries(), entries.as_slice()); + assert_eq!(page.next_after(), Some(cursor)); + assert_eq!(page.checkpoint(), checkpoint(18)); + assert!( + StockRewrapPage::from_store_report( + &request, + vec![entries[0], entries[0]], + false, + checkpoint(18) + ) + .is_err() + ); + assert!( + StockRewrapPage::from_store_report( + &request, + (0..17) + .map(|index| StockRewrapState::from_store_report( + admission(&request, original, index), + Some(rewrapped(&request, original, index)) + ) + .unwrap()) + .collect(), + false, + checkpoint(19) + ) + .is_err() + ); + assert!( + StockRewrapPage::from_store_report(&request, entries.clone(), false, checkpoint(1)) + .is_err() + ); + assert!( + StockRewrapPage::from_store_report(&request, vec![entries[0]], true, checkpoint(18)) + .is_err() + ); +} fn progress(intent: &DeliveryIntent, accepted: &[bool; 2]) -> Vec<StockDeliveryTargetProgress> { intent .targets() diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs @@ -709,7 +709,7 @@ fn stock_root_context( input: &super::AttachmentInput, version: i64, ) -> Result<EnvelopeContext, WorkspaceError> { - if matches!(version, 4..=17) { + if matches!(version, 4..=18) { use sha2::{Digest, Sha256}; let namespace = radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment( @@ -748,8 +748,10 @@ fn stock_root_context( b"radroots.seller_stock.authority_context.v15\0".as_slice() } else if version == 16 { b"radroots.seller_stock.authority_context.v16\0".as_slice() - } else { + } else if version == 17 { b"radroots.seller_stock.authority_context.v17\0".as_slice() + } else { + b"radroots.seller_stock.authority_context.v18\0".as_slice() }); hash.update(wire.as_slice()); let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into()); @@ -784,8 +786,10 @@ fn stock_root_context( "radroots.seller_stock.authority.v15" } else if version == 16 { "radroots.seller_stock.authority.v16" - } else { + } else if version == 17 { "radroots.seller_stock.authority.v17" + } else { + "radroots.seller_stock.authority.v18" }) .map_err(|_| WorkspaceError::InvalidInput)?, )); @@ -903,12 +907,12 @@ fn stock_record_context_for_catalog( ) -> Result<EnvelopeContext, WorkspaceError> { let original = stock_record_context(input, kind, id)?; let schema = match (catalog, kind) { - (2, _) | (3..=17, "pool") => return Ok(original), + (2, _) | (3..=18, "pool") => return Ok(original), (3, "operation") => "radroots.seller_stock.operation.v2", (4, "operation") => "radroots.seller_stock.operation.v3", (5 | 6, "operation") => "radroots.seller_stock.operation.v4", - (7..=17, "operation") => "radroots.seller_stock.operation.v5", - (3..=17, "movement") => "radroots.seller_stock.movement.v2", + (7..=18, "operation") => "radroots.seller_stock.operation.v5", + (3..=18, "movement") => "radroots.seller_stock.movement.v2", _ => return Err(WorkspaceError::RecoveryRequired), }; Ok(EnvelopeContext::new( diff --git a/crates/storage_sqlite/src/workspace/recovery.rs b/crates/storage_sqlite/src/workspace/recovery.rs @@ -10,7 +10,7 @@ use radroots_storage::{ command::{ArtifactEvidence, EvidenceCaptureOutcome, OperationError}, inventory::{ StockDeliveryObservation, StockDeliveryObservationOutcome, StockEnvelopeOutcome, - StockEnvelopeRequest, StockEvidenceOutcome, StockEvidenceRequest, + StockEvidenceOutcome, StockEvidenceRequest, StockRewrapRequest, }, workspace::seller_stock::SellerAuthoritySelection, }; @@ -44,10 +44,11 @@ enum Material { Unissued(Box<stock::issuance::unissued::Request>), Envelope( Box<( - StockEnvelopeRequest, + stock::envelope::CaptureRequest, radroots_storage::command::PrivateEnvelopeCandidate, )>, ), + RewrapAdmission(Box<StockRewrapRequest>), Observation(Box<(super::WorkspaceBinding, StockDeliveryObservation)>), } impl Material { @@ -56,7 +57,8 @@ impl Material { Self::Outbox(value) => &value.0, Self::Stock(value) => value.binding().input(), Self::Unissued(value) => value.binding.input(), - Self::Envelope(value) => value.0.binding().input(), + Self::Envelope(value) => value.0.source().binding().input(), + Self::RewrapAdmission(value) => value.source().binding().input(), Self::Observation(value) => value.0.input(), } } @@ -67,12 +69,14 @@ enum Captured { Unissued(stock::StockUnissuedOutcome), Envelope(StockEnvelopeOutcome), Observation(StockDeliveryObservationOutcome), + RewrapAdmission, } impl Captured { fn committed(&self) -> bool { matches!( self, - Self::Outbox(EvidenceCaptureOutcome::Committed(_)) + Self::RewrapAdmission + | Self::Outbox(EvidenceCaptureOutcome::Committed(_)) | Self::Stock(StockEvidenceOutcome::Committed(_)) | Self::Unissued(stock::StockUnissuedOutcome::Committed(_)) | Self::Envelope(StockEnvelopeOutcome::Committed(_)) @@ -134,7 +138,7 @@ impl RecoveryTurn<'_> { } pub(super) async fn capture_envelope( &mut self, - request: StockEnvelopeRequest, + request: stock::envelope::CaptureRequest, proof: AttachmentProof, candidate: radroots_storage::command::PrivateEnvelopeCandidate, ) -> Result<StockEnvelopeOutcome, OperationError> { @@ -142,7 +146,7 @@ impl RecoveryTurn<'_> { return Err(OperationError::UnsupportedOperation); } if !SellerAuthoritySelection::from_attachment(self.selected) - .matches_attachment(request.binding().input()) + .matches_attachment(request.source().binding().input()) { return Err(OperationError::Unauthorized); } @@ -154,6 +158,27 @@ impl RecoveryTurn<'_> { _ => Err(OperationError::RecoveryRequired), } } + pub(super) async fn reconcile_rewrap_admission( + &mut self, + request: StockRewrapRequest, + proof: AttachmentProof, + ) -> Result<(), OperationError> { + if self.namespace.kind() != Kind::SellerStock { + return Err(OperationError::UnsupportedOperation); + } + if !SellerAuthoritySelection::from_attachment(self.selected) + .matches_attachment(request.source().binding().input()) + { + return Err(OperationError::Unauthorized); + } + match self + .recover(Material::RewrapAdmission(Box::new(request)), proof) + .await? + { + Captured::RewrapAdmission => Ok(()), + _ => Err(OperationError::RecoveryRequired), + } + } pub(super) async fn capture_observation( &mut self, binding: super::WorkspaceBinding, @@ -222,7 +247,7 @@ impl RecoveryTurn<'_> { let result = match material { Material::Envelope(value) => { let (request, candidate) = *value; - Box::pin(stock::envelope::capture( + Box::pin(stock::envelope::capture_obtained( &mut stock::inventory::Turn { connection, namespace: self.namespace, @@ -238,6 +263,22 @@ impl RecoveryTurn<'_> { .await .map(Captured::Envelope) } + Material::RewrapAdmission(request) => { + Box::pin(stock::envelope::reconcile_rewrap_admission( + &mut stock::inventory::Turn { + connection, + namespace: self.namespace, + selected: self.selected, + crypto: self.crypto, + clock: self.clock, + uncertain: uncertainty, + }, + *request, + proof, + )) + .await + .map(|()| Captured::RewrapAdmission) + } Material::Observation(value) => { let (binding, observation) = *value; Box::pin(stock::delivery::capture_observation( diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs @@ -445,10 +445,10 @@ struct AuthorityV8 { } impl Authority { fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> { - if !matches!(self.catalog, 8..=17) && self.public_sources.is_some() { + if !matches!(self.catalog, 8..=18) && self.public_sources.is_some() { return Err(WorkspaceError::RecoveryRequired); } - if matches!(self.catalog, 8..=17) { + if matches!(self.catalog, 8..=18) { let public_sources = self .public_sources .ok_or(WorkspaceError::RecoveryRequired)?; @@ -700,7 +700,7 @@ impl Authority { public_sources: None, } } - 8..=17 => { + 8..=18 => { let value: AuthorityV8 = closed_record(bytes)?; value.public_sources.validate()?; if i64::from(value.version) != catalog @@ -831,7 +831,7 @@ pub(super) async fn initialize( .await .map_err(|_| WorkspaceError::StorageFailure)?; } - sqlx::query("PRAGMA user_version=17") + sqlx::query("PRAGMA user_version=18") .execute(&mut *tx) .await .map_err(|_| WorkspaceError::StorageFailure)?; @@ -1173,6 +1173,9 @@ impl radroots_storage::inventory::InventoryStore for NativeWorkspace { >, > { Box::pin(async move { + if request.envelope_event_id().is_some() { + return Err(radroots_storage::command::OperationError::InvalidCommand); + } self.worker .capture_stock_envelope(request, proof, candidate.retained_copy()) .await @@ -1204,11 +1207,104 @@ impl radroots_storage::inventory::InventoryStore for NativeWorkspace { >, > { Box::pin(async move { + if request.envelope_event_id().is_some() { + return Err(radroots_storage::command::OperationError::InvalidCommand); + } self.worker .reconcile_stock_envelope(request, proof, candidate.retained_copy()) .await }) } + fn prepare_stock_rewrap( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result< + radroots_storage::inventory::StockRewrapOutcome, + radroots_storage::command::OperationError, + >, + > { + Box::pin(self.worker.prepare_stock_rewrap(request, proof)) + } + fn stock_rewrap_attempt( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result< + Option<radroots_storage::inventory::StockRewrapState>, + radroots_storage::command::OperationError, + >, + > { + Box::pin(self.worker.stock_rewrap_attempt(request, proof)) + } + fn reconcile_stock_rewrap_admission( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture<'_, Result<(), radroots_storage::command::OperationError>> + { + Box::pin(self.worker.reconcile_stock_rewrap_admission(request, proof)) + } + fn capture_stock_rewrap<'a>( + &'a self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + candidate: &'a radroots_storage::command::PrivateEnvelopeCandidate, + ) -> radroots_transport::BoxFuture< + 'a, + Result< + radroots_storage::inventory::StockEnvelopeOutcome, + radroots_storage::command::OperationError, + >, + > { + Box::pin(async move { + if request.source().envelope_event_id().is_none() { + return Err(radroots_storage::command::OperationError::InvalidCommand); + } + self.worker + .capture_stock_rewrap(request, proof, candidate.retained_copy(), false) + .await + }) + } + fn reconcile_stock_rewrap<'a>( + &'a self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + candidate: &'a radroots_storage::command::PrivateEnvelopeCandidate, + ) -> radroots_transport::BoxFuture< + 'a, + Result< + radroots_storage::inventory::StockEnvelopeOutcome, + radroots_storage::command::OperationError, + >, + > { + Box::pin(async move { + if request.source().envelope_event_id().is_none() { + return Err(radroots_storage::command::OperationError::InvalidCommand); + } + self.worker + .capture_stock_rewrap(request, proof, candidate.retained_copy(), true) + .await + }) + } + fn stock_rewraps( + &self, + request: radroots_storage::inventory::StockEnvelopeRequest, + after: Option<radroots_domain::Sequence>, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result< + radroots_storage::inventory::StockRewrapPage, + radroots_storage::command::OperationError, + >, + > { + Box::pin(self.worker.stock_rewraps(request, after, proof)) + } fn prepare_stock_delivery_attempt( &self, request: radroots_storage::inventory::StockDeliveryRequest, diff --git a/crates/storage_sqlite/src/workspace/stock/consent.rs b/crates/storage_sqlite/src/workspace/stock/consent.rs @@ -424,7 +424,7 @@ pub(in crate::workspace) async fn issue( proof: AttachmentProof, ) -> Result<StockConsentOutcome, OperationError> { let access = turn.access(&binding, minimum, &proof).await?; - if !matches!(access.authority.catalog, 7..=17) { + if !matches!(access.authority.catalog, 7..=18) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() @@ -685,7 +685,7 @@ pub(in crate::workspace) async fn query( proof: AttachmentProof, ) -> Result<Option<StockConsentReceipt>, OperationError> { let access = turn.access(&binding, minimum, &proof).await?; - if !matches!(access.authority.catalog, 7..=17) { + if !matches!(access.authority.catalog, 7..=18) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() && access.current.input().grant_id() != subject { diff --git a/crates/storage_sqlite/src/workspace/stock/consent/test_provider.rs b/crates/storage_sqlite/src/workspace/stock/consent/test_provider.rs @@ -74,7 +74,11 @@ impl KeyWrapping for Provider { fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> { Box::pin(async move { let result = self.inner.wrap(request).await; - if request.context().payload_schema().as_str() == "radroots.seller_stock.authority.v17" + if request.context().payload_schema().as_str() + == format!( + "radroots.seller_stock.authority.v{}", + crate::workspace::stock::schema::CURRENT + ) { self.gate.pause(); } diff --git a/crates/storage_sqlite/src/workspace/stock/delivery.rs b/crates/storage_sqlite/src/workspace/stock/delivery.rs @@ -181,7 +181,7 @@ impl Prepared { append: Append, body: &[u8], ) -> Result<Self, OperationError> { - if authority.catalog != 17 { + if !matches!(authority.catalog, 17 | 18) { return Err(OperationError::UnsupportedOperation); } let before = authority diff --git a/crates/storage_sqlite/src/workspace/stock/delivery/attempt.rs b/crates/storage_sqlite/src/workspace/stock/delivery/attempt.rs @@ -206,7 +206,9 @@ async fn decode_entry( || h.revision <= consent.frame.header.revision || plan.bound.attempt().operation_id() != original.operation_id() || plan.bound.attempt().command_digest() != h.digest - || plan.frame.header.actor != outer.frame.header.actor + || (outer.frame.header.family == ledger::Family::Envelope + && plan.frame.header.actor != outer.frame.header.actor) + || plan.frame.header.actor.participant() != outer.frame.header.actor.participant() || command.operation_id() != original.operation_id() || consent.command.digest() != h.digest || value.at >= consent.expires diff --git a/crates/storage_sqlite/src/workspace/stock/delivery/graph.rs b/crates/storage_sqlite/src/workspace/stock/delivery/graph.rs @@ -11,17 +11,19 @@ struct Endpoint { struct Recipient { participant: PublicKey, source: Option<envelope::Retained>, + original: Option<radroots_storage::inventory::StockEnvelopeReceipt>, first: Option<DeliveryIntent>, + first_source: Option<radroots_storage::inventory::StockEnvelopeReceipt>, attempts: u16, endpoints: Vec<Endpoint>, } impl Recipient { fn observe_attempt(&mut self, value: &StockDeliveryAttempt) -> Result<(), OperationError> { - if self - .source - .as_ref() - .is_none_or(|source| source.source.receipt() != value.source().receipt()) - { + if self.original.as_ref().is_none_or(|source| { + source.evidence() != value.source().receipt().evidence() + || source.installation_transaction_id() + != value.source().receipt().installation_transaction_id() + }) { return Err(OperationError::RecoveryRequired); } if let Some(original) = &self.first { @@ -30,6 +32,7 @@ impl Recipient { } } else { self.first = Some(value.intent().clone()); + self.first_source = Some(value.source().receipt()); self.endpoints = value .intent() .targets() @@ -78,6 +81,13 @@ impl Recipient { if value.target_ordinal() == 0 || value.target_ordinal() > endpoint.attempts { return Err(OperationError::RecoveryRequired); } + if self + .source + .as_ref() + .is_none_or(|source| source.source.receipt().event_id() != value.source().event_id()) + { + return Ok(()); + } endpoint.accepted |= value.kind() == DeliveryObservationKind::Accepted; endpoint.last = Some(value.kind()); endpoint.observed = value.observed_at_unix_ms(); @@ -130,11 +140,27 @@ impl Graph { *participant, None, )?; - let source = Box::pin(envelope::lookup(turn, &selector)).await?; + let original_source = Box::pin(envelope::lookup(turn, &selector)).await?; + let original = original_source.as_ref().map(|value| value.source.receipt()); + let source = if *participant == request.recipient() { + if let Some(event) = request.envelope_event_id() { + Some( + Box::pin(envelope::lookup(turn, &selector.with_envelope(event))) + .await? + .ok_or(OperationError::MissingHistory)?, + ) + } else { + original_source + } + } else { + original_source + }; recipients.push(Recipient { participant: *participant, source, + original, first: None, + first_source: None, attempts: 0, endpoints: vec![], }); @@ -295,9 +321,10 @@ impl Graph { ) }) .collect::<Result<Vec<_>, _>>()?; - StockDeliverySummary::from_store_report( + StockDeliverySummary::from_store_report_with_policy_source( request, value.source.as_ref().map(|source| source.source.receipt()), + value.first_source, value.first.clone(), value.attempts, targets, diff --git a/crates/storage_sqlite/src/workspace/stock/delivery/observation_operations.rs b/crates/storage_sqlite/src/workspace/stock/delivery/observation_operations.rs @@ -18,7 +18,7 @@ pub(in crate::workspace) async fn capture_observation( } let (authority, credential, root, grant) = super::super::read(turn.connection, input, turn.crypto).await?; - if authority.catalog != 17 { + if !matches!(authority.catalog, 17 | 18) { return Err(OperationError::UnsupportedOperation); } credential.authenticate_retained_capture(input, &proof)?; @@ -35,6 +35,11 @@ pub(in crate::workspace) async fn capture_observation( supplied.source().recipient(), None, )?; + let source = if authority.catalog >= 18 { + source.with_envelope(supplied.source().event_id()) + } else { + source + }; let witness = Box::pin(envelope::full_proof(turn, &source, &authority)).await?; let mut graph = Box::pin(Graph::read( turn, @@ -175,7 +180,11 @@ pub(in crate::workspace) async fn page( after: Option<Sequence>, proof: AttachmentProof, ) -> Result<StockDeliveryObservationPage, OperationError> { - let (auth, witness, _) = Box::pin(operations::read(turn, &source, &proof, None)).await?; + let (auth, witness, graph) = Box::pin(operations::read(turn, &source, &proof, None)).await?; + let selected_event = graph + .source(source.recipient()) + .ok() + .map(|value| value.source.receipt().event_id()); let current = auth .access .authority @@ -184,13 +193,18 @@ pub(in crate::workspace) async fn page( if after.is_some_and(|after| after > current.revision) { return Err(WorkspaceError::StaleCheckpoint.into()); } - 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=? AND d.recipient=? AND o.revision>? ORDER BY o.revision LIMIT 17") + 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=? AND d.recipient=? AND o.revision>? ORDER BY o.revision LIMIT 2305") .bind(turn.selected.participant().as_bytes().as_slice()).bind(source.operation_id().as_bytes().as_slice()) .bind(source.recipient().as_bytes().as_slice()).bind(after.map_or(0, |value| value.get()) as i64) .fetch_all(&mut *turn.connection).await.map_err(|_|OperationError::RecoveryRequired)?; - let more = rows.len() > PAGE_MAX; - let mut entries = Vec::with_capacity(rows.len().min(PAGE_MAX)); - for row in rows.into_iter().take(PAGE_MAX) { + if rows.len() > OBSERVATION_COUNT_MAX { + return Err(OperationError::RecoveryRequired); + } + // The protected history is globally bounded and already authenticated. + // Filter by the actual attempt source, never an unauthenticated event index. + // Retain at most one extra matching descriptor to establish continuation. + let mut entries = Vec::with_capacity(PAGE_MAX + 1); + for row in rows { let bytes: Vec<u8> = row .try_get(0) .map_err(|_| OperationError::RecoveryRequired)?; @@ -209,8 +223,15 @@ pub(in crate::workspace) async fn page( )) .await? .ok_or(OperationError::RecoveryRequired)?; - entries.push(value.receipt); + if selected_event == Some(value.receipt.observation().source().event_id()) { + entries.push(value.receipt); + if entries.len() > PAGE_MAX { + break; + } + } } + let more = entries.len() > PAGE_MAX; + entries.truncate(PAGE_MAX); Box::pin(operations::confirm_read(turn, &auth, &witness, &proof)).await?; StockDeliveryObservationPage::from_store_report( &source, diff --git a/crates/storage_sqlite/src/workspace/stock/delivery/operations.rs b/crates/storage_sqlite/src/workspace/stock/delivery/operations.rs @@ -11,7 +11,7 @@ async fn authorized( .fetch_one(&mut *turn.connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - if catalog != 17 { + if !matches!(catalog, 17 | 18) { return Err(OperationError::UnsupportedOperation); } let loading = signing_plan::load( @@ -23,7 +23,7 @@ async fn authorized( proof, ); let auth = Box::pin(loading).await?; - if auth.access.authority.catalog != 17 { + if !matches!(auth.access.authority.catalog, 17 | 18) { return Err(OperationError::UnsupportedOperation); } if !auth @@ -263,6 +263,13 @@ pub(in crate::workspace) async fn query_attempt( ) -> Result<Option<StockDeliveryAttempt>, OperationError> { validate_request(&request)?; let (auth, witness, mut graph) = Box::pin(read(turn, &source, &proof, Some(&request))).await?; + if graph.found_attempt.as_ref().is_some_and(|value| { + graph.source(source.recipient()).is_ok_and(|selected| { + selected.source.receipt().event_id() != value.report.source().receipt().event_id() + }) + }) { + return Err(OperationError::InvalidEvidence); + } Box::pin(confirm_read(turn, &auth, &witness, &proof)).await?; Ok(graph.found_attempt.take().map(|value| value.report)) } diff --git a/crates/storage_sqlite/src/workspace/stock/envelope.rs b/crates/storage_sqlite/src/workspace/stock/envelope.rs @@ -14,10 +14,57 @@ use sqlx::Row; use zeroize::Zeroizing; mod codec; mod projection; +mod rewrap; +mod rewrap_admission; use codec::Original; pub(in crate::workspace::stock) use codec::Retained; pub(super) use codec::read_entry; -pub(super) use projection::{Projection, raw_projection}; +pub(super) use projection::{ + Projection, raw_admission_projection, raw_projection, raw_rewrap_projection, +}; +pub(in crate::workspace) use rewrap_admission::prepare as prepare_rewrap; +pub(in crate::workspace::stock) async fn admission_history( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + binding: &WorkspaceBinding, + entry: OperationId, +) -> Result<ledger::HistoryEntry, OperationError> { + Ok(Box::pin(rewrap_admission::read_entry( + connection, input, crypto, binding, entry, + )) + .await? + .into_history()) +} +pub(in crate::workspace) use rewrap::{attempt as rewrap_attempt, page}; +pub(in crate::workspace) use rewrap_admission::reconcile as reconcile_rewrap_admission; +pub(in crate::workspace) enum CaptureRequest { + Original(Box<StockEnvelopeRequest>), + Rewrap(Box<radroots_storage::inventory::StockRewrapRequest>), +} +impl CaptureRequest { + pub(in crate::workspace) fn source(&self) -> &StockEnvelopeRequest { + match self { + Self::Original(request) => request, + Self::Rewrap(request) => request.source(), + } + } +} +pub(in crate::workspace) async fn capture_obtained( + turn: &mut Turn<'_>, + request: CaptureRequest, + proof: AttachmentProof, + candidate: PrivateEnvelopeCandidate, +) -> Result<StockEnvelopeOutcome, OperationError> { + match request { + CaptureRequest::Original(request) => { + Box::pin(capture(turn, *request, proof, candidate)).await + } + CaptureRequest::Rewrap(request) => { + Box::pin(rewrap::capture(turn, *request, proof, candidate)).await + } + } +} async fn selected_entry( connection: &mut SqliteConnection, @@ -26,7 +73,7 @@ async fn selected_entry( recipient: PublicKey, ) -> Result<Option<OperationId>, OperationError> { let row: Option<Vec<u8>> = sqlx::query_scalar( - "SELECT entry_id FROM stock_envelopes WHERE actor=? AND operation_id=? AND recipient=?", + "SELECT CASE WHEN length(entry_id)=32 THEN entry_id END FROM stock_envelopes WHERE actor=? AND operation_id=? AND recipient=?", ) .bind(actor.as_bytes().as_slice()) .bind(operation.as_bytes().as_slice()) @@ -42,7 +89,7 @@ async fn selected_entry( }) .transpose() } -pub(in crate::workspace::stock) async fn lookup( +async fn lookup_original( turn: &mut Turn<'_>, request: &StockEnvelopeRequest, ) -> Result<Option<Retained>, OperationError> { @@ -74,6 +121,22 @@ pub(in crate::workspace::stock) async fn lookup( } Ok(Some(retained)) } +pub(in crate::workspace::stock) async fn lookup( + turn: &mut Turn<'_>, + request: &StockEnvelopeRequest, +) -> Result<Option<Retained>, OperationError> { + let original = Box::pin(lookup_original(turn, request)).await?; + let Some(event) = request.envelope_event_id() else { + return Ok(original); + }; + if original + .as_ref() + .is_some_and(|value| value.source.receipt().event_id() == event) + { + return Ok(original); + } + Box::pin(rewrap::lookup(turn, request, event)).await +} pub(in crate::workspace::stock) async fn full_proof( turn: &mut Turn<'_>, request: &StockEnvelopeRequest, @@ -113,6 +176,9 @@ pub(in crate::workspace) async fn capture( proof: AttachmentProof, candidate: PrivateEnvelopeCandidate, ) -> Result<StockEnvelopeOutcome, OperationError> { + if request.envelope_event_id().is_some() { + return Err(OperationError::InvalidCommand); + } if *turn.uncertain { return Err(OperationError::RecoveryRequired); } @@ -122,7 +188,7 @@ pub(in crate::workspace) async fn capture( return Err(OperationError::Unauthorized); } let (authority, record, root, grant) = super::read(turn.connection, input, turn.crypto).await?; - if !matches!(authority.catalog, 16 | 17) { + if !matches!(authority.catalog, 16..=18) { return Err(OperationError::UnsupportedOperation); } record.authenticate_retained_capture(input, &proof)?; @@ -247,7 +313,7 @@ pub(in crate::workspace) async fn capture( } if let Some(frame) = &frame { frame.insert_record(&mut tx).await?; - Projection { + Projection::Original { operation: request.operation_id(), recipient: request.recipient(), } @@ -297,11 +363,12 @@ pub(in crate::workspace) async fn read( return Err(OperationError::RecoveryRequired); } turn.namespace.validate()?; + let input = request.binding().input(); let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") .fetch_one(&mut *turn.connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - if !matches!(catalog, 16 | 17) { + if !matches!(catalog, 16..=18) { return Err(OperationError::UnsupportedOperation); } let auth = Box::pin(super::signing_plan::load( @@ -313,7 +380,7 @@ pub(in crate::workspace) async fn read( &proof, )) .await?; - if !matches!(auth.access.authority.catalog, 16 | 17) { + if !matches!(auth.access.authority.catalog, 16..=18) { return Err(OperationError::UnsupportedOperation); } let witness = Box::pin(full_proof(turn, &request, &auth.access.authority)).await?; @@ -330,6 +397,19 @@ pub(in crate::workspace) async fn read( witness.confirm(&mut tx).await?; if let Some(retained) = &retained { retained.confirm(&mut tx).await?; + } else { + let count: i64 = if let Some(event) = request.envelope_event_id() { + sqlx::query_scalar("SELECT count(*) FROM stock_rewraps WHERE actor=? AND operation_id=? AND recipient=? AND event_id=?") + .bind(input.participant().as_bytes().as_slice()) + .bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .bind(event.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_| OperationError::RecoveryRequired)? + } else { + sqlx::query_scalar("SELECT count(*) FROM stock_envelopes WHERE actor=? AND operation_id=? AND recipient=?") + .bind(input.participant().as_bytes().as_slice()) + .bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .fetch_one(&mut *tx).await.map_err(|_| OperationError::RecoveryRequired)? + }; + if count != 0 { return Err(OperationError::RecoveryRequired); } } turn.namespace.validate()?; Ok(()) diff --git a/crates/storage_sqlite/src/workspace/stock/envelope/codec.rs b/crates/storage_sqlite/src/workspace/stock/envelope/codec.rs @@ -153,8 +153,8 @@ pub(super) fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { pub(in crate::workspace::stock) struct Retained { pub(in crate::workspace::stock) frame: ledger::Retained, pub source: StockEnvelopeSource, - projection: Projection, - installation: OperationId, + pub(super) projection: Projection, + pub(super) installation: OperationId, } impl Retained { pub(in crate::workspace::stock) fn installation_entry(&self) -> OperationId { @@ -221,10 +221,30 @@ pub(in crate::workspace::stock) async fn read_entry( let Some(frame) = Box::pin(ledger::read(connection, input, crypto, entry)).await? else { return Ok(None); }; + if frame.header.family == ledger::Family::RewrappedEnvelope { + return Ok(Some( + Box::pin(super::rewrap::decode_entry( + connection, input, crypto, binding, frame, + )) + .await?, + )); + } Ok(Some( Box::pin(decode_entry(connection, input, crypto, binding, frame)).await?, )) } +pub(super) async fn read_original_entry( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + binding: &WorkspaceBinding, + entry: OperationId, +) -> Result<Retained, OperationError> { + let frame = Box::pin(ledger::read(connection, input, crypto, entry)) + .await? + .ok_or(OperationError::RecoveryRequired)?; + Box::pin(decode_entry(connection, input, crypto, binding, frame)).await +} async fn decode_entry( connection: &mut SqliteConnection, input: &AttachmentInput, @@ -336,7 +356,7 @@ async fn decode_entry( .map_err(|_| OperationError::RecoveryRequired)?; let retained = Retained { installation: original.installation.frame.header.operation, - projection: Projection { + projection: Projection::Original { operation, recipient: receipt.recipient(), }, diff --git a/crates/storage_sqlite/src/workspace/stock/envelope/projection.rs b/crates/storage_sqlite/src/workspace/stock/envelope/projection.rs @@ -1,9 +1,22 @@ -//! Exact body-derived cache witness. It cannot authorize capture or transport. +//! Exact body-derived original, wrapping-admission and capture indexes. use super::*; #[derive(Clone, Copy)] -pub(in crate::workspace::stock) struct Projection { - pub operation: OperationId, - pub recipient: PublicKey, +pub(in crate::workspace::stock) enum Projection { + Original { + operation: OperationId, + recipient: PublicKey, + }, + Admission { + operation: OperationId, + recipient: PublicKey, + request: OperationId, + }, + Rewrap { + operation: OperationId, + recipient: PublicKey, + admission: OperationId, + event: EnvelopeEventId, + }, } impl Projection { pub(in crate::workspace::stock) fn digest( @@ -12,11 +25,45 @@ impl Projection { entry: OperationId, ) -> [u8; 32] { let mut hash = Sha256::new(); - hash.update(b"radroots.seller_stock.envelope_projection.v1\0"); + let (operation, recipient) = match self { + Self::Original { + operation, + recipient, + } => { + hash.update(b"radroots.seller_stock.envelope_projection.v1\0"); + (operation, recipient) + } + Self::Admission { + operation, + recipient, + .. + } => { + hash.update(b"radroots.seller_stock.rewrap_admission_projection.v1\0"); + (operation, recipient) + } + Self::Rewrap { + operation, + recipient, + .. + } => { + hash.update(b"radroots.seller_stock.rewrap_projection.v1\0"); + (operation, recipient) + } + }; hash.update(actor.as_bytes()); hash.update(entry.as_bytes()); - hash.update(self.operation.as_bytes()); - hash.update(self.recipient.as_bytes()); + hash.update(operation.as_bytes()); + hash.update(recipient.as_bytes()); + match self { + Self::Original { .. } => {} + Self::Admission { request, .. } => hash.update(request.as_bytes()), + Self::Rewrap { + admission, event, .. + } => { + hash.update(admission.as_bytes()); + hash.update(event.as_bytes()); + } + } hash.finalize().into() } pub(super) async fn insert( @@ -25,16 +72,35 @@ impl Projection { actor: PublicKey, entry: OperationId, ) -> Result<(), OperationError> { - sqlx::query( - "INSERT INTO stock_envelopes(actor,operation_id,recipient,entry_id) VALUES(?,?,?,?)", - ) - .bind(actor.as_bytes().as_slice()) - .bind(self.operation.as_bytes().as_slice()) - .bind(self.recipient.as_bytes().as_slice()) - .bind(entry.as_bytes().as_slice()) - .execute(connection) - .await - .map_err(|_| OperationError::StorageFailure)?; + match self { + Self::Original { + operation, + recipient, + } => { + sqlx::query("INSERT INTO stock_envelopes(actor,operation_id,recipient,entry_id) VALUES(?,?,?,?)") + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(recipient.as_bytes().as_slice()).bind(entry.as_bytes().as_slice()) + .execute(connection).await.map_err(|_| OperationError::StorageFailure)?; + } + Self::Admission { + operation, + recipient, + request, + } => { + sqlx::query("INSERT INTO stock_rewrap_admissions(actor,operation_id,recipient,request_id,entry_id) VALUES(?,?,?,?,?)") + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(recipient.as_bytes().as_slice()) + .bind(request.as_bytes().as_slice()).bind(entry.as_bytes().as_slice()).execute(connection).await.map_err(|_| OperationError::StorageFailure)?; + } + Self::Rewrap { + operation, + recipient, + admission, + event, + } => { + sqlx::query("INSERT INTO stock_rewraps(actor,operation_id,recipient,admission_entry,event_id,entry_id) VALUES(?,?,?,?,?,?)") + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(recipient.as_bytes().as_slice()) + .bind(admission.as_bytes().as_slice()).bind(event.as_bytes().as_slice()).bind(entry.as_bytes().as_slice()).execute(connection).await.map_err(|_| OperationError::StorageFailure)?; + } + } Ok(()) } pub(super) async fn confirm( @@ -43,21 +109,36 @@ impl Projection { actor: PublicKey, entry: OperationId, ) -> Result<(), OperationError> { - if raw_projection(connection, actor.as_bytes(), entry.as_bytes()).await? - != self.digest(actor, entry) - { + let found = match self { + Self::Original { .. } => { + raw_projection(connection, actor.as_bytes(), entry.as_bytes()).await? + } + Self::Admission { .. } => { + raw_admission_projection(connection, actor.as_bytes(), entry.as_bytes()).await? + } + Self::Rewrap { .. } => { + raw_rewrap_projection(connection, actor.as_bytes(), entry.as_bytes()).await? + } + }; + if found != self.digest(actor, entry) { return Err(OperationError::RecoveryRequired); } Ok(()) } } +fn bytes(row: &sqlx::sqlite::SqliteRow, index: usize) -> Result<[u8; 32], OperationError> { + row.try_get::<Vec<u8>, _>(index) + .map_err(|_| OperationError::RecoveryRequired)? + .try_into() + .map_err(|_| OperationError::RecoveryRequired) +} pub(in crate::workspace::stock) async fn raw_projection( connection: &mut SqliteConnection, actor: &[u8; 32], entry: &[u8; 32], ) -> Result<[u8; 32], OperationError> { let row = sqlx::query( - "SELECT operation_id,recipient FROM stock_envelopes WHERE actor=? AND entry_id=?", + "SELECT CASE WHEN length(operation_id)=32 THEN operation_id END,CASE WHEN length(recipient)=32 THEN recipient END FROM stock_envelopes WHERE actor=? AND entry_id=?", ) .bind(actor.as_slice()) .bind(entry.as_slice()) @@ -65,16 +146,47 @@ pub(in crate::workspace::stock) async fn raw_projection( .await .map_err(|_| OperationError::RecoveryRequired)? .ok_or(OperationError::RecoveryRequired)?; - let field = |index| { - row.try_get::<Vec<u8>, _>(index) - .map_err(|_| OperationError::RecoveryRequired)? - .try_into() - .map_err(|_| OperationError::RecoveryRequired) - }; - Ok(Projection { - operation: OperationId::from_bytes(field(0)?), - recipient: PublicKey::from_bytes(field(1)?) + Ok(Projection::Original { + operation: OperationId::from_bytes(bytes(&row, 0)?), + recipient: PublicKey::from_bytes(bytes(&row, 1)?) + .map_err(|_| OperationError::RecoveryRequired)?, + } + .digest( + PublicKey::from_bytes(*actor).map_err(|_| OperationError::RecoveryRequired)?, + OperationId::from_bytes(*entry), + )) +} +pub(in crate::workspace::stock) async fn raw_admission_projection( + connection: &mut SqliteConnection, + actor: &[u8; 32], + entry: &[u8; 32], +) -> Result<[u8; 32], OperationError> { + let row = sqlx::query("SELECT CASE WHEN length(operation_id)=32 THEN operation_id END,CASE WHEN length(recipient)=32 THEN recipient END,CASE WHEN length(request_id)=32 THEN request_id END FROM stock_rewrap_admissions WHERE actor=? AND entry_id=?") + .bind(actor.as_slice()).bind(entry.as_slice()).fetch_optional(connection).await.map_err(|_| OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + Ok(Projection::Admission { + operation: OperationId::from_bytes(bytes(&row, 0)?), + recipient: PublicKey::from_bytes(bytes(&row, 1)?) + .map_err(|_| OperationError::RecoveryRequired)?, + request: OperationId::from_bytes(bytes(&row, 2)?), + } + .digest( + PublicKey::from_bytes(*actor).map_err(|_| OperationError::RecoveryRequired)?, + OperationId::from_bytes(*entry), + )) +} +pub(in crate::workspace::stock) async fn raw_rewrap_projection( + connection: &mut SqliteConnection, + actor: &[u8; 32], + entry: &[u8; 32], +) -> Result<[u8; 32], OperationError> { + let row = sqlx::query("SELECT CASE WHEN length(operation_id)=32 THEN operation_id END,CASE WHEN length(recipient)=32 THEN recipient END,CASE WHEN length(admission_entry)=32 THEN admission_entry END,CASE WHEN length(event_id)=32 THEN event_id END FROM stock_rewraps WHERE actor=? AND entry_id=?") + .bind(actor.as_slice()).bind(entry.as_slice()).fetch_optional(connection).await.map_err(|_| OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + Ok(Projection::Rewrap { + operation: OperationId::from_bytes(bytes(&row, 0)?), + recipient: PublicKey::from_bytes(bytes(&row, 1)?) .map_err(|_| OperationError::RecoveryRequired)?, + admission: OperationId::from_bytes(bytes(&row, 2)?), + event: EnvelopeEventId::from_bytes(bytes(&row, 3)?), } .digest( PublicKey::from_bytes(*actor).map_err(|_| OperationError::RecoveryRequired)?, diff --git a/crates/storage_sqlite/src/workspace/stock/envelope/rewrap.rs b/crates/storage_sqlite/src/workspace/stock/envelope/rewrap.rs @@ -0,0 +1,389 @@ +//! Additional obtained outers reference immutable original F10/S/T2. +use super::*; +use nostr::JsonUtil; +use radroots_storage::inventory::{StockRewrapPage, StockRewrapRequest, StockRewrapState}; +use std::num::NonZeroU64; +#[path = "rewrap_capture.rs"] +mod capture; +#[path = "rewrap_selection.rs"] +pub(super) mod selection; +pub(super) use capture::capture; +use selection::SelectionWitness; +const MAGIC: &[u8; 8] = b"RDSTRW1\0"; +const PREFIX: usize = 117; +const COUNT_MAX: i64 = 192; + +fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.rewrap_chain.v1\0"); + hash.update([14]); + hash.update(codec::head(header, body).as_bytes()); + CheckpointDigest::from_bytes(hash.finalize().into()) +} +fn encode( + original: &rewrap_admission::Admitted, + request: &StockEnvelopeRequest, + raw: &str, +) -> Zeroizing<Vec<u8>> { + let mut body = Zeroizing::new(Vec::with_capacity(PREFIX + raw.len())); + body.extend_from_slice(MAGIC); + body.extend_from_slice(original.frame.header.operation.as_bytes()); + body.extend_from_slice(original.frame.header.transaction.as_bytes()); + body.extend_from_slice(original.frame.header.head.as_bytes()); + body.push(u8::from(request.observed_at_unix_ms().is_some())); + body.extend_from_slice( + &request + .observed_at_unix_ms() + .map(NonZeroU64::get) + .unwrap_or(0) + .to_be_bytes(), + ); + body.extend_from_slice(&(raw.len() as u32).to_be_bytes()); + body.extend_from_slice(raw.as_bytes()); + body +} +pub(super) async fn lookup( + turn: &mut Turn<'_>, + request: &StockEnvelopeRequest, + event: EnvelopeEventId, +) -> Result<Option<Retained>, OperationError> { + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *turn.connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if catalog != 18 { + return Err(OperationError::UnsupportedOperation); + } + let entry: Option<Vec<u8>> = sqlx::query_scalar("SELECT CASE WHEN length(entry_id)=32 THEN entry_id END FROM stock_rewraps WHERE actor=? AND operation_id=? AND recipient=? AND event_id=?") + .bind(turn.selected.participant().as_bytes().as_slice()) + .bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .bind(event.as_bytes().as_slice()).fetch_optional(&mut *turn.connection).await.map_err(|_| OperationError::RecoveryRequired)?; + let Some(entry) = entry else { return Ok(None) }; + let entry = OperationId::from_bytes( + entry + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let retained = Box::pin(read_entry( + turn.connection, + turn.selected, + turn.crypto, + request.binding(), + entry, + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let receipt = retained.source.receipt(); + if retained.frame.header.family != ledger::Family::RewrappedEnvelope + || receipt.attempt().operation_id() != request.operation_id() + || receipt.attempt().command_digest() != request.command_digest() + || receipt.recipient() != request.recipient() + || receipt.event_id() != event + { + return Err(OperationError::RecoveryRequired); + } + Ok(Some(retained)) +} +pub(super) async fn decode_entry( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + binding: &WorkspaceBinding, + frame: ledger::Retained, +) -> Result<Retained, OperationError> { + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + let body = frame.body.as_slice(); + if catalog != 18 + || frame.header.family != ledger::Family::RewrappedEnvelope + || !(PREFIX..=PREFIX + 65536).contains(&body.len()) + || &body[..8] != MAGIC + { + return Err(OperationError::RecoveryRequired); + } + let array = |start, end| -> Result<[u8; 32], OperationError> { + body[start..end] + .try_into() + .map_err(|_| OperationError::RecoveryRequired) + }; + // F14 references a strict F13, whose strict F10 link cannot recurse. + let admission = Box::pin(rewrap_admission::read_entry( + connection, + input, + crypto, + binding, + OperationId::from_bytes(array(8, 40)?), + )) + .await?; + let h = &frame.header; + let original_header = &admission.frame.header; + if original_header.transaction != TransactionId::from_bytes(array(40, 72)?) + || original_header.head != CheckpointDigest::from_bytes(array(72, 104)?) + || h.actor != original_header.actor + || h.digest != original_header.digest + || h.related_operation != original_header.related_operation + || h.order != original_header.order + || h.revision <= original_header.revision + || head(h, body) != h.head + { + return Err(OperationError::RecoveryRequired); + } + let at = u64::from_be_bytes( + body[105..113] + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let observed = match (body[104], at) { + (0, 0) => None, + (1, value) if value > 0 => NonZeroU64::new(value), + _ => return Err(OperationError::RecoveryRequired), + }; + let length = u32::from_be_bytes( + body[113..117] + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ) as usize; + if length != body.len() - PREFIX { + return Err(OperationError::RecoveryRequired); + } + let raw = std::str::from_utf8(&body[PREFIX..]).map_err(|_| OperationError::RecoveryRequired)?; + let event = nostr::Event::from_json(raw).map_err(|_| OperationError::RecoveryRequired)?; + let event = EnvelopeEventId::from_bytes(event.id.to_bytes()); + let first = admission.report.original(); + if first.event_id() == event { + return Err(OperationError::RecoveryRequired); + } + let operation = h + .related_operation + .ok_or(OperationError::RecoveryRequired)?; + let request = StockEnvelopeRequest::new( + binding.clone(), + first.checkpoint(), + operation, + h.digest, + first.recipient(), + observed, + )? + .with_envelope(event); + let receipt = StockEnvelopeReceipt::from_committed_store( + &request, + CommitAttempt::new( + input.workspace_id(), + operation, + h.digest, + Some(h.transaction), + ), + first.evidence(), + first.installation_transaction_id(), + event, + Sha256::digest(raw.as_bytes()).into(), + InventoryCheckpointRef::from_host_metadata(input.authority(), h.revision, Some(h.head))?, + )? + .with_rewrap_admission(&admission.report)?; + let source = StockEnvelopeSource::from_retained_wire(receipt, raw) + .map_err(|_| OperationError::RecoveryRequired)?; + let retained = Retained { + installation: codec::read_original_entry( + connection, + input, + crypto, + binding, + admission.original_entry, + ) + .await? + .installation_entry(), + projection: Projection::Rewrap { + operation, + recipient: receipt.recipient(), + admission: admission.frame.header.operation, + event, + }, + frame, + source, + }; + retained.confirm(connection).await?; + Ok(retained) +} +pub(in crate::workspace) async fn page( + turn: &mut Turn<'_>, + request: StockEnvelopeRequest, + after: Option<Sequence>, + proof: AttachmentProof, +) -> Result<StockRewrapPage, OperationError> { + let (entries, more, checkpoint) = query(turn, &request, after, None, &proof).await?; + StockRewrapPage::from_store_report(&request, entries, more, checkpoint) +} +pub(in crate::workspace) async fn attempt( + turn: &mut Turn<'_>, + request: StockRewrapRequest, + proof: AttachmentProof, +) -> Result<Option<StockRewrapState>, OperationError> { + let (mut entries, _, _) = query( + turn, + request.source(), + None, + Some(request.rewrap_id()), + &proof, + ) + .await?; + Ok(entries.pop()) +} +async fn state( + turn: &mut Turn<'_>, + binding: &WorkspaceBinding, + admission: rewrap_admission::Admitted, +) -> Result<StockRewrapState, OperationError> { + let entry: Option<Vec<u8>> = sqlx::query_scalar( + "SELECT CASE WHEN length(entry_id)=32 THEN entry_id END FROM stock_rewraps WHERE actor=? AND admission_entry=?", + ) + .bind(turn.selected.participant().as_bytes().as_slice()) + .bind(admission.frame.header.operation.as_bytes().as_slice()) + .fetch_optional(&mut *turn.connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + let captured = if let Some(entry) = entry { + let retained = Box::pin(read_entry( + turn.connection, + turn.selected, + turn.crypto, + binding, + OperationId::from_bytes( + entry + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ), + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if retained.frame.header.family != ledger::Family::RewrappedEnvelope { + return Err(OperationError::RecoveryRequired); + } + Some(retained.source.receipt()) + } else { + None + }; + StockRewrapState::from_store_report(admission.report, captured) +} +async fn query( + turn: &mut Turn<'_>, + request: &StockEnvelopeRequest, + after: Option<Sequence>, + id: Option<OperationId>, + proof: &AttachmentProof, +) -> Result<(Vec<StockRewrapState>, bool, InventoryCheckpointRef), OperationError> { + if *turn.uncertain { + return Err(OperationError::RecoveryRequired); + } + if request.envelope_event_id().is_some() { + return Err(OperationError::InvalidCommand); + } + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *turn.connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if catalog != 18 { + return Err(OperationError::UnsupportedOperation); + } + let auth = Box::pin(super::super::signing_plan::load( + turn, + request.binding(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), + proof, + )) + .await?; + if auth.access.authority.catalog != 18 + || !auth + .original + .receipt + .rumor() + .recipients() + .contains(&request.recipient()) + { + return Err(OperationError::InvalidEvidence); + } + let current = auth + .access + .authority + .inventory + .ok_or(OperationError::RecoveryRequired)?; + if after.is_some_and(|cursor| cursor > current.revision) { + return Err(OperationError::StaleState); + } + let witness = Box::pin(full_proof(turn, request, &auth.access.authority)).await?; + let selection = SelectionWitness::read(turn.connection, request).await?; + let rows = if let Some(id) = id { + sqlx::query("SELECT CASE WHEN length(entry_id)=32 THEN entry_id END FROM stock_rewrap_admissions WHERE actor=? AND operation_id=? AND recipient=? AND request_id=?") + .bind(turn.selected.participant().as_bytes().as_slice()).bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .bind(id.as_bytes().as_slice()).fetch_all(&mut *turn.connection).await + } else { + sqlx::query("SELECT CASE WHEN length(r.entry_id)=32 THEN r.entry_id END FROM stock_rewrap_admissions r JOIN stock_operations o ON o.actor=r.actor AND o.operation_id=r.entry_id WHERE r.actor=? AND r.operation_id=? AND r.recipient=? AND o.revision>? ORDER BY o.revision LIMIT 17") + .bind(turn.selected.participant().as_bytes().as_slice()).bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .bind(after.map(|value| value.get() as i64).unwrap_or(0)).fetch_all(&mut *turn.connection).await + }.map_err(|_| OperationError::RecoveryRequired)?; + let more = rows.len() > 16; + let mut entries = Vec::with_capacity(rows.len().min(16)); + for row in rows.into_iter().take(16) { + let entry: Vec<u8> = row + .try_get(0) + .map_err(|_| OperationError::RecoveryRequired)?; + let admission = Box::pin(rewrap_admission::read_entry( + turn.connection, + turn.selected, + turn.crypto, + request.binding(), + OperationId::from_bytes( + entry + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ), + )) + .await?; + let first = admission.report.original(); + if first.recipient() != request.recipient() + || first.attempt().operation_id() != request.operation_id() + || first.attempt().command_digest() != request.command_digest() + { + return Err(OperationError::RecoveryRequired); + } + entries.push(Box::pin(state(turn, request.binding(), admission)).await?); + } + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<(), OperationError> = async { + auth.confirm(&mut tx, turn.namespace, turn.clock, proof, false) + .await?; + inventory::check_head(&mut tx, current).await?; + witness.confirm(&mut tx).await?; + selection.confirm(&mut tx, request).await?; + turn.namespace.validate()?; + Ok(()) + } + .await; + if let Err(error) = checked { + if tx.rollback().await.is_err() { + *turn.uncertain = true; + } + return Err(error); + } + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + Ok(( + entries, + more, + InventoryCheckpointRef::from_host_metadata( + turn.selected.authority(), + current.revision, + current.head, + )? + .with_optional_authorization(auth.access.authority.authorization), + )) +} diff --git a/crates/storage_sqlite/src/workspace/stock/envelope/rewrap_admission.rs b/crates/storage_sqlite/src/workspace/stock/envelope/rewrap_admission.rs @@ -0,0 +1,498 @@ +//! Confirmed one-invocation wrapping admission, separate from obtained bytes. +use super::*; +use radroots_domain::UnixSeconds; +use radroots_storage::inventory::{StockRewrapAdmission, StockRewrapOutcome, StockRewrapRequest}; +const MAGIC: &[u8; 8] = b"RDSTRP1\0"; +const BYTES: usize = 248; +pub(super) struct Admitted { + pub frame: ledger::Retained, + pub report: StockRewrapAdmission, + pub original_entry: OperationId, + projection: Projection, +} +fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.rewrap_admission_chain.v1\0"); + hash.update([13]); + hash.update(codec::head(header, body).as_bytes()); + CheckpointDigest::from_bytes(hash.finalize().into()) +} +fn reference(body: &mut Vec<u8>, header: &ledger::Header) { + body.extend_from_slice(header.operation.as_bytes()); + body.extend_from_slice(header.transaction.as_bytes()); + body.extend_from_slice(header.head.as_bytes()); +} +fn encode( + id: OperationId, + original: &Retained, + consent: &super::super::consent::Retained, + at: UnixSeconds, + expires: UnixSeconds, +) -> Zeroizing<Vec<u8>> { + let mut body = Zeroizing::new(Vec::with_capacity(BYTES)); + body.extend_from_slice(MAGIC); + body.extend_from_slice(id.as_bytes()); + reference(&mut body, &original.frame.header); + reference(&mut body, &consent.frame.header); + body.extend_from_slice(&at.get().to_be_bytes()); + body.extend_from_slice(&expires.get().to_be_bytes()); + body +} +pub(super) async fn lookup( + turn: &mut Turn<'_>, + request: &StockRewrapRequest, +) -> Result<Option<Admitted>, OperationError> { + let source = request.source(); + let entry: Option<Vec<u8>> = sqlx::query_scalar("SELECT CASE WHEN length(entry_id)=32 THEN entry_id END FROM stock_rewrap_admissions WHERE actor=? AND operation_id=? AND recipient=? AND request_id=?") + .bind(turn.selected.participant().as_bytes().as_slice()).bind(source.operation_id().as_bytes().as_slice()) + .bind(source.recipient().as_bytes().as_slice()).bind(request.rewrap_id().as_bytes().as_slice()) + .fetch_optional(&mut *turn.connection).await.map_err(|_| OperationError::RecoveryRequired)?; + let Some(entry) = entry else { return Ok(None) }; + let retained = Box::pin(read_entry( + turn.connection, + turn.selected, + turn.crypto, + source.binding(), + OperationId::from_bytes( + entry + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ), + )) + .await?; + let original = retained.report.original(); + if retained.report.rewrap_id() != request.rewrap_id() + || original.attempt().operation_id() != source.operation_id() + || original.attempt().command_digest() != source.command_digest() + || original.recipient() != source.recipient() + { + return Err(OperationError::RecoveryRequired); + } + Ok(Some(retained)) +} +pub(super) async fn read_entry( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + binding: &WorkspaceBinding, + entry: OperationId, +) -> Result<Admitted, OperationError> { + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + let frame = Box::pin(ledger::read(connection, input, crypto, entry)) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let (authority, _, _, _) = super::super::read(connection, input, crypto).await?; + let body = frame.body.as_slice(); + if catalog != 18 + || frame.header.family != ledger::Family::RewrapAdmission + || body.len() != BYTES + || &body[..8] != MAGIC + { + return Err(OperationError::RecoveryRequired); + } + let array = |start, end| -> Result<[u8; 32], OperationError> { + body[start..end] + .try_into() + .map_err(|_| OperationError::RecoveryRequired) + }; + let id = OperationId::from_bytes(array(8, 40)?); + let original = Box::pin(codec::read_original_entry( + connection, + input, + crypto, + binding, + OperationId::from_bytes(array(40, 72)?), + )) + .await?; + let consent = Box::pin(super::super::consent::read( + connection, + input, + crypto, + authority.input.grant_id(), + OperationId::from_bytes(array(136, 168)?), + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let at = UnixSeconds::new(u64::from_be_bytes( + body[232..240] + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + )) + .map_err(|_| OperationError::RecoveryRequired)?; + let expires = UnixSeconds::new(u64::from_be_bytes( + body[240..248] + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + )) + .map_err(|_| OperationError::RecoveryRequired)?; + let h = &frame.header; + let first = &original.frame.header; + if first.transaction != TransactionId::from_bytes(array(72, 104)?) + || first.head != CheckpointDigest::from_bytes(array(104, 136)?) + || consent.frame.header.transaction != TransactionId::from_bytes(array(168, 200)?) + || consent.frame.header.head != CheckpointDigest::from_bytes(array(200, 232)?) + || h.actor.participant() != first.actor.participant() + || h.actor.grant_id() != Some(consent.subject) + || h.digest != first.digest + || h.related_operation != first.related_operation + || h.order != first.order + || h.revision <= first.revision + || h.revision <= consent.frame.header.revision + || consent.command.context().operation_id() + != first + .related_operation + .ok_or(OperationError::RecoveryRequired)? + || consent.command.digest() != h.digest + || at < consent.observed_at + || expires > consent.expires + || at >= expires + || expires.get() - at.get() > 30 + || head(h, body) != h.head + { + return Err(OperationError::RecoveryRequired); + } + let source = original.source.receipt(); + let request = StockRewrapRequest::new( + StockEnvelopeRequest::new( + binding.clone(), + source.checkpoint(), + source.attempt().operation_id(), + source.attempt().command_digest(), + source.recipient(), + None, + )?, + id, + ); + let report = StockRewrapAdmission::from_store_report( + &request, + source, + h.transaction, + at, + expires, + InventoryCheckpointRef::from_host_metadata(input.authority(), h.revision, Some(h.head))?, + )?; + let retained = Admitted { + original_entry: first.operation, + projection: Projection::Admission { + operation: source.attempt().operation_id(), + recipient: source.recipient(), + request: id, + }, + frame, + report, + }; + retained.confirm(connection).await?; + Ok(retained) +} +impl Admitted { + pub(super) async fn confirm( + &self, + connection: &mut SqliteConnection, + ) -> Result<(), OperationError> { + ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?; + ledger::confirm_parts( + connection, + self.frame.header.actor, + self.frame.header.operation, + self.frame.parts_witness, + self.frame.header.parts, + ) + .await?; + self.projection + .confirm( + connection, + self.frame.header.actor.participant(), + self.frame.header.operation, + ) + .await?; + let count: i64 = sqlx::query_scalar( + "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?", + ) + .bind(self.frame.header.actor.participant().as_bytes().as_slice()) + .bind(self.frame.header.operation.as_bytes().as_slice()) + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if count != 0 { + return Err(OperationError::RecoveryRequired); + } + Ok(()) + } + pub(super) fn into_history(self) -> ledger::HistoryEntry { + ledger::HistoryEntry { + envelope: Some(self.projection), + delivery: None, + aborted: None, + preparation: None, + header: self.frame.header, + protected: self.frame.protected, + parts_witness: self.frame.parts_witness, + pools: vec![], + mapping: None, + movements: vec![], + signing: None, + installation: None, + local_record: None, + } + } +} +pub(in crate::workspace) async fn prepare( + turn: &mut Turn<'_>, + request: StockRewrapRequest, + proof: AttachmentProof, +) -> Result<StockRewrapOutcome, OperationError> { + if *turn.uncertain { + return Err(OperationError::RecoveryRequired); + } + let source = request.source(); + if source.envelope_event_id().is_some() { + return Err(OperationError::InvalidCommand); + } + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *turn.connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if catalog != 18 { + return Err(OperationError::UnsupportedOperation); + } + let auth = Box::pin(super::super::signing_plan::load( + turn, + source.binding(), + source.minimum_checkpoint(), + source.operation_id(), + source.command_digest(), + &proof, + )) + .await?; + if auth.access.authority.catalog != 18 + || !auth + .original + .receipt + .rumor() + .recipients() + .contains(&source.recipient()) + { + return Err(OperationError::InvalidEvidence); + } + let witness = Box::pin(full_proof(turn, source, &auth.access.authority)).await?; + let selection = + super::rewrap::selection::SelectionWitness::read(turn.connection, source).await?; + let original = Box::pin(lookup_original(turn, source)) + .await? + .ok_or(OperationError::MissingHistory)?; + let existing = Box::pin(lookup(turn, &request)).await?; + let before = auth + .access + .authority + .inventory + .ok_or(OperationError::RecoveryRequired)?; + let (frame, root, report) = if let Some(existing) = &existing { + if existing.report.original() != original.source.receipt() { + return Err(OperationError::RecoveryRequired); + } + (None, None, existing.report) + } else { + if selection.count >= 192 { + return Err(OperationError::DeliveryAttemptLimit); + } + let at = auth.access.current.observed_at(); + let expires = UnixSeconds::new( + at.get() + .checked_add(30) + .ok_or(OperationError::DeadlineExceeded)?, + ) + .map_err(|_| OperationError::DeadlineExceeded)? + .min(auth.access.current.expires_at()) + .min(auth.consent.expires); + if expires <= at { + return Err(OperationError::DeadlineExceeded); + } + let revision = Sequence::new( + before + .revision + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?; + let body = encode(request.rewrap_id(), &original, &auth.consent, at, expires); + let mut header = ledger::Header { + version: 5, + family: ledger::Family::RewrapAdmission, + namespace: SellerAuthoritySelection::from_attachment(turn.selected), + actor: auth.access.current.actor(), + operation: OperationId::from_bytes(super::super::super::random()?), + digest: source.command_digest(), + transaction: TransactionId::from_bytes(super::super::super::random()?), + revision, + previous: before.head, + head: CheckpointDigest::from_bytes([0; 32]), + pool: None, + order: original.frame.header.order, + related_operation: Some(source.operation_id()), + subject_grant: None, + bytes: 0, + parts: 0, + body_digest: [0; 32], + }; + header.head = head(&header, &body); + let report = StockRewrapAdmission::from_store_report( + &request, + original.source.receipt(), + header.transaction, + at, + expires, + InventoryCheckpointRef::from_host_metadata( + turn.selected.authority(), + revision, + Some(header.head), + )?, + )?; + let frame = ledger::prepare(turn.crypto, turn.selected, header, &body).await?; + let mut next = auth.access.authority.clone(); + next.inventory = Some(InventoryCheckpoint { + revision, + head: Some(frame.header.head), + ..before + }); + let root = turn + .crypto + .seal_stock_root(turn.selected, next.catalog, &next.encode()?) + .await?; + (Some(frame), Some(root), report) + }; + let unknown = || { + StockRewrapOutcome::Unknown(CommitAttempt::new( + turn.selected.workspace_id(), + source.operation_id(), + source.command_digest(), + Some(report.transaction_id()), + )) + }; + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<(), OperationError> = async { + let current = auth + .confirm(&mut tx, turn.namespace, turn.clock, &proof, false) + .await?; + if frame.is_some() && current.observed_at() >= report.expires_at() { + return Err(OperationError::DeadlineExceeded); + } + inventory::check_head(&mut tx, before).await?; + witness.confirm(&mut tx).await?; + selection.confirm(&mut tx, source).await?; + original.confirm(&mut tx).await?; + if let Some(existing) = &existing { + existing.confirm(&mut tx).await?; + } + if let Some(frame) = &frame { + frame.insert_record(&mut tx).await?; + Projection::Admission { + operation: source.operation_id(), + recipient: source.recipient(), + request: request.rewrap_id(), + } + .insert(&mut tx, turn.selected.participant(), frame.header.operation) + .await?; + let changed = sqlx::query( + "UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?", + ) + .bind(root.as_ref().ok_or(OperationError::RecoveryRequired)?) + .bind(&auth.access.root) + .execute(&mut *tx) + .await + .map_err(|_| OperationError::StorageFailure)?; + if changed.rows_affected() != 1 { + return Err(OperationError::RecoveryRequired); + } + } + turn.namespace.validate()?; + Ok(()) + } + .await; + if let Err(error) = checked { + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Ok(unknown()); + } + return Err(error); + } + let done = if frame.is_some() { + tx.commit().await + } else { + tx.rollback().await + }; + if done.is_err() { + *turn.uncertain = true; + return Ok(unknown()); + } + Ok(if frame.is_some() { + StockRewrapOutcome::Claimed(Box::new(report)) + } else { + StockRewrapOutcome::Retained(Box::new(report)) + }) +} + +/// Repair the original writer fence without returning history or a new permit. +pub(in crate::workspace) async fn reconcile( + turn: &mut Turn<'_>, + request: StockRewrapRequest, + proof: AttachmentProof, +) -> Result<(), OperationError> { + if *turn.uncertain { + return Err(OperationError::RecoveryRequired); + } + let source = request.source(); + if source.envelope_event_id().is_some() { + return Err(OperationError::InvalidCommand); + } + let input = source.binding().input(); + if !SellerAuthoritySelection::from_attachment(turn.selected).matches_attachment(input) { + return Err(OperationError::Unauthorized); + } + let (authority, record, root, grant) = + super::super::read(turn.connection, input, turn.crypto).await?; + if authority.catalog != 18 { + return Err(OperationError::UnsupportedOperation); + } + record.authenticate_retained_capture(input, &proof)?; + let witness = Box::pin(full_proof(turn, source, &authority)).await?; + let selection = + super::rewrap::selection::SelectionWitness::read(turn.connection, source).await?; + let existing = Box::pin(lookup(turn, &request)).await?; + if existing + .as_ref() + .is_some_and(|value| value.frame.header.actor != source.binding().actor()) + { + return Err(OperationError::Unauthorized); + } + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<(), OperationError> = async { + turn.namespace.validate()?; + super::super::unchanged(&mut tx, input, authority.catalog, &root, &grant).await?; + record.authenticate_retained_capture(input, &proof)?; + witness.confirm(&mut tx).await?; + selection.confirm(&mut tx, source).await?; + if let Some(existing) = &existing { + existing.confirm(&mut tx).await?; + } + turn.namespace.validate()?; + Ok(()) + } + .await; + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + checked +} diff --git a/crates/storage_sqlite/src/workspace/stock/envelope/rewrap_capture.rs b/crates/storage_sqlite/src/workspace/stock/envelope/rewrap_capture.rs @@ -0,0 +1,224 @@ +//! Confirm original obtained rewrap bytes without provider IO inside SQL. +use super::*; + +pub(in crate::workspace::stock::envelope) async fn capture( + turn: &mut Turn<'_>, + request: StockRewrapRequest, + proof: AttachmentProof, + candidate: PrivateEnvelopeCandidate, +) -> Result<StockEnvelopeOutcome, OperationError> { + if *turn.uncertain { + return Err(OperationError::RecoveryRequired); + } + turn.namespace.validate()?; + let rewrap = request; + let request = rewrap.source(); + let event = request + .envelope_event_id() + .ok_or(OperationError::InvalidCommand)?; + if event != candidate.event_id() || candidate.recipient() != request.recipient() { + return Err(OperationError::InvalidEvidence); + } + let input = request.binding().input(); + if !SellerAuthoritySelection::from_attachment(turn.selected).matches_attachment(input) { + return Err(OperationError::Unauthorized); + } + let (authority, record, root, grant) = + super::super::super::read(turn.connection, input, turn.crypto).await?; + if authority.catalog != 18 { + return Err(OperationError::UnsupportedOperation); + } + record.authenticate_retained_capture(input, &proof)?; + let witness = Box::pin(full_proof(turn, request, &authority)).await?; + let selection = SelectionWitness::read(turn.connection, request).await?; + let admission = Box::pin(rewrap_admission::lookup(turn, &rewrap)) + .await? + .ok_or(OperationError::MissingHistory)?; + if admission.frame.header.actor != request.binding().actor() { + return Err(OperationError::Unauthorized); + } + let first = Box::pin(lookup_original(turn, request)) + .await? + .ok_or(OperationError::MissingHistory)?; + if first.source.receipt() != admission.report.original() + || first.source.receipt().event_id() == event + { + return Err(OperationError::InvalidEvidence); + } + let original = Box::pin(Original::load(turn, request)).await?; + if original.evidence.frame.header.actor.participant() != request.binding().actor().participant() + || first.source.receipt().evidence() != original.evidence.value.receipt() + || first.source.receipt().installation_transaction_id() + != original.installation.frame.header.transaction + || original + .installation + .receipt + .publication_work() + .iter() + .any(|work| work.recipient() == candidate.author()) + { + return Err(OperationError::InvalidEvidence); + } + candidate.with_wrapping_key(|key| { + original.evidence.value.with_json(|seal| { + super::super::super::super::delivery::containment::verify( + candidate.raw_json(), + candidate.author(), + key, + request.recipient(), + seal, + original.evidence.value.receipt().digest(), + ) + }) + })?; + let existing = Box::pin(lookup(turn, request, event)).await?; + let captured: Option<Vec<u8>> = sqlx::query_scalar( + "SELECT CASE WHEN length(event_id)=32 THEN event_id END FROM stock_rewraps WHERE actor=? AND admission_entry=?", + ) + .bind(input.participant().as_bytes().as_slice()) + .bind(admission.frame.header.operation.as_bytes().as_slice()) + .fetch_optional(&mut *turn.connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if captured + .as_deref() + .is_some_and(|old| old != event.as_bytes().as_slice()) + { + return Err(OperationError::IdempotencyConflict); + } + let before = authority + .inventory + .ok_or(OperationError::RecoveryRequired)?; + let (frame, updated, receipt) = if let Some(old) = &existing { + if old.source.with_json(|raw| raw != candidate.raw_json()) + || old.source.receipt().evidence() != first.source.receipt().evidence() + || old.source.receipt().rewrap_admission_transaction_id() + != Some(admission.report.transaction_id()) + || old.source.receipt().installation_transaction_id() + != first.source.receipt().installation_transaction_id() + { + return Err(OperationError::IdempotencyConflict); + } + (None, None, old.source.receipt()) + } else { + let revision = Sequence::new( + before + .revision + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?; + let body = encode(&admission, request, candidate.raw_json()); + let mut header = ledger::Header { + version: 5, + family: ledger::Family::RewrappedEnvelope, + namespace: SellerAuthoritySelection::from_attachment(turn.selected), + actor: request.binding().actor(), + operation: OperationId::from_bytes(super::super::super::super::random()?), + digest: request.command_digest(), + transaction: TransactionId::from_bytes(super::super::super::super::random()?), + revision, + previous: before.head, + head: CheckpointDigest::from_bytes([0; 32]), + pool: None, + order: first.frame.header.order, + related_operation: Some(request.operation_id()), + subject_grant: None, + bytes: 0, + parts: 0, + body_digest: [0; 32], + }; + header.head = head(&header, &body); + let receipt = StockEnvelopeReceipt::from_committed_store( + request, + CommitAttempt::new( + input.workspace_id(), + request.operation_id(), + request.command_digest(), + Some(header.transaction), + ), + first.source.receipt().evidence(), + first.source.receipt().installation_transaction_id(), + event, + *candidate.digest(), + InventoryCheckpointRef::from_host_metadata( + input.authority(), + revision, + Some(header.head), + )?, + )?; + let receipt = receipt.with_rewrap_admission(&admission.report)?; + let frame = ledger::prepare(turn.crypto, turn.selected, header, &body).await?; + let mut next = authority.clone(); + next.inventory = Some(InventoryCheckpoint { + revision, + head: Some(frame.header.head), + ..before + }); + let updated = turn + .crypto + .seal_stock_root(turn.selected, next.catalog, &next.encode()?) + .await?; + (Some(frame), Some(updated), receipt) + }; + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let changed: Result<(), OperationError> = async { + turn.namespace.validate()?; + super::super::super::unchanged(&mut tx, input, authority.catalog, &root, &grant).await?; + record.authenticate_retained_capture(input, &proof)?; + witness.confirm(&mut tx).await?; + selection.confirm(&mut tx, request).await?; + first.confirm(&mut tx).await?; + admission.confirm(&mut tx).await?; + if let Some(old) = &existing { + old.confirm(&mut tx).await?; + } + if let Some(frame) = &frame { + frame.insert_record(&mut tx).await?; + Projection::Rewrap { + operation: request.operation_id(), + recipient: request.recipient(), + admission: admission.frame.header.operation, + event, + } + .insert(&mut tx, input.participant(), frame.header.operation) + .await?; + let changed = sqlx::query( + "UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?", + ) + .bind(updated.as_ref().ok_or(OperationError::RecoveryRequired)?) + .bind(&root) + .execute(&mut *tx) + .await + .map_err(|_| OperationError::StorageFailure)?; + if changed.rows_affected() != 1 { + return Err(OperationError::RecoveryRequired); + } + } + turn.namespace.validate()?; + Ok(()) + } + .await; + if let Err(error) = changed { + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Ok(StockEnvelopeOutcome::Unknown(receipt.attempt())); + } + return Err(error); + } + let done = if frame.is_some() { + tx.commit().await + } else { + tx.rollback().await + }; + if done.is_err() { + *turn.uncertain = true; + return Ok(StockEnvelopeOutcome::Unknown(receipt.attempt())); + } + Ok(StockEnvelopeOutcome::Committed(Box::new(receipt))) +} diff --git a/crates/storage_sqlite/src/workspace/stock/envelope/rewrap_selection.rs b/crates/storage_sqlite/src/workspace/stock/envelope/rewrap_selection.rs @@ -0,0 +1,80 @@ +//! Bounded natural-index witness, including rows outside the protected chain. +use super::*; +#[derive(Eq, PartialEq)] +pub(in crate::workspace::stock::envelope) struct SelectionWitness { + pub count: usize, + digest: [u8; 32], +} +impl SelectionWitness { + pub(in crate::workspace::stock::envelope) async fn read( + connection: &mut SqliteConnection, + request: &StockEnvelopeRequest, + ) -> Result<Self, OperationError> { + let admissions = sqlx::query("SELECT CASE WHEN length(r.request_id)=32 THEN r.request_id END,CASE WHEN length(r.entry_id)=32 THEN r.entry_id END,o.family,CASE WHEN length(o.related_operation)=32 THEN o.related_operation END FROM stock_rewrap_admissions r LEFT JOIN stock_operations o ON o.actor=r.actor AND o.operation_id=r.entry_id WHERE r.actor=? AND r.operation_id=? AND r.recipient=? ORDER BY r.request_id,r.entry_id LIMIT 193") + .bind(request.binding().input().participant().as_bytes().as_slice()) + .bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .fetch_all(&mut *connection).await.map_err(|_| OperationError::RecoveryRequired)?; + let captures = sqlx::query("SELECT CASE WHEN length(r.event_id)=32 THEN r.event_id END,CASE WHEN length(r.entry_id)=32 THEN r.entry_id END,o.family,CASE WHEN length(o.related_operation)=32 THEN o.related_operation END,CASE WHEN length(r.admission_entry)=32 THEN r.admission_entry END,CASE WHEN length(a.entry_id)=32 THEN a.entry_id END FROM stock_rewraps r LEFT JOIN stock_operations o ON o.actor=r.actor AND o.operation_id=r.entry_id LEFT JOIN stock_rewrap_admissions a ON a.actor=r.actor AND a.operation_id=r.operation_id AND a.recipient=r.recipient AND a.entry_id=r.admission_entry WHERE r.actor=? AND r.operation_id=? AND r.recipient=? ORDER BY r.event_id,r.entry_id LIMIT 193") + .bind(request.binding().input().participant().as_bytes().as_slice()) + .bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) + .fetch_all(connection).await.map_err(|_| OperationError::RecoveryRequired)?; + if admissions.len() > COUNT_MAX as usize || captures.len() > admissions.len() { + return Err(OperationError::RecoveryRequired); + } + let mut hash = Sha256::new(); + hash.update(b"radroots.seller_stock.rewrap_selection.v1\0"); + for (rows, family) in [(&admissions, 13), (&captures, 14)] { + hash.update([family as u8]); + hash.update((rows.len() as u16).to_be_bytes()); + for row in rows { + if row + .try_get::<Option<i64>, _>(2) + .map_err(|_| OperationError::RecoveryRequired)? + != Some(family) + || row + .try_get::<Option<Vec<u8>>, _>(3) + .map_err(|_| OperationError::RecoveryRequired)? + .as_deref() + != Some(request.operation_id().as_bytes().as_slice()) + { + return Err(OperationError::RecoveryRequired); + } + for index in 0..2 { + let bytes: Vec<u8> = row + .try_get(index) + .map_err(|_| OperationError::RecoveryRequired)?; + if bytes.len() != 32 { + return Err(OperationError::RecoveryRequired); + } + hash.update(bytes); + } + if family == 14 { + let admission: Vec<u8> = row + .try_get(4) + .map_err(|_| OperationError::RecoveryRequired)?; + let matched: Option<Vec<u8>> = row + .try_get(5) + .map_err(|_| OperationError::RecoveryRequired)?; + if admission.len() != 32 || matched.as_deref() != Some(admission.as_slice()) { + return Err(OperationError::RecoveryRequired); + } + hash.update(admission); + } + } + } + Ok(Self { + count: admissions.len(), + digest: hash.finalize().into(), + }) + } + pub(in crate::workspace::stock::envelope) async fn confirm( + &self, + connection: &mut SqliteConnection, + request: &StockEnvelopeRequest, + ) -> Result<(), OperationError> { + if Self::read(connection, request).await? != *self { + return Err(OperationError::RecoveryRequired); + } + Ok(()) + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/grants.rs b/crates/storage_sqlite/src/workspace/stock/grants.rs @@ -324,7 +324,7 @@ pub(in crate::workspace) async fn change( } let (mut authority, record, old_root, old_grant) = super::read(turn.connection, change.caller.input(), turn.crypto).await?; - if !(4..=17).contains(&authority.catalog) { + if !(4..=18).contains(&authority.catalog) { return Err(WorkspaceError::Unauthorized); } let catalog = authority.catalog; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory.rs b/crates/storage_sqlite/src/workspace/stock/inventory.rs @@ -452,7 +452,7 @@ impl Turn<'_> { access.authority.authorization, mapping.as_ref().map(|value| value.effect), )?; - let framed = if matches!(catalog, 7..=17) { + let framed = if matches!(catalog, 7..=18) { Some( super::ledger::prepare( self.crypto, @@ -866,7 +866,7 @@ pub(super) async fn read_operation( .fetch_one(&mut *connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - let (frame, request, decoded) = if matches!(catalog, 7..=17) { + let (frame, request, decoded) = if matches!(catalog, 7..=18) { let retained = super::ledger::read(connection, input, crypto, operation) .await? .ok_or(OperationError::RecoveryRequired)?; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort.rs @@ -160,7 +160,7 @@ async fn abort_authorized( proof: AttachmentProof, auth: signing_plan::Authorized, ) -> Result<StockAbortOutcome, OperationError> { - if !matches!(auth.access.authority.catalog, 13..=17) { + if !matches!(auth.access.authority.catalog, 13..=18) { return Err(OperationError::UnsupportedOperation); } let (old, identity) = Box::pin(existing(turn, &auth.access, request.operation_id())).await?; @@ -381,7 +381,7 @@ pub(in crate::workspace) async fn read( &proof, )) .await?; - if !matches!(auth.access.authority.catalog, 13..=17) { + if !matches!(auth.access.authority.catalog, 13..=18) { return Err(OperationError::UnsupportedOperation); } let (old, identity) = Box::pin(existing(turn, &auth.access, request.operation_id())).await?; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort/proof.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort/proof.rs @@ -150,7 +150,7 @@ pub(super) async fn prepare( recipient: *recipient, }), Some(original) => { - if !matches!(auth.access.authority.catalog, 15..=17) { + if !matches!(auth.access.authority.catalog, 15..=18) { return Err(OperationError::RecoveryRequired); } if at < original.report.claimed_at() { @@ -180,7 +180,7 @@ pub(super) async fn prepare( } } } - let payload = if matches!(auth.access.authority.catalog, 15..=17) { + let payload = if matches!(auth.access.authority.catalog, 15..=18) { Payload::Current(Box::new( encoded .try_into() @@ -217,7 +217,7 @@ pub(super) async fn read( .fetch_one(&mut *connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - if !matches!(catalog, 15..=17) { + if !matches!(catalog, 15..=18) { return Err(OperationError::RecoveryRequired); } for (proof, expected) in proofs.iter().zip(recipients) { diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs b/crates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs @@ -236,7 +236,7 @@ pub(in crate::workspace) async fn admit( let access = turn .access(request.binding(), request.minimum_checkpoint(), &proof) .await?; - if !matches!(access.authority.catalog, 9..=17) { + if !matches!(access.authority.catalog, 9..=18) { return Err(OperationError::UnsupportedOperation); } let command = request.command(); diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/acceptance/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/acceptance/codec.rs @@ -325,7 +325,7 @@ pub(in crate::workspace::stock) async fn read( .map_err(|_| OperationError::RecoveryRequired)?; let operation_keyed = match catalog { 1..=12 => false, - 13..=17 => true, + 13..=18 => true, _ => return Err(OperationError::RecoveryRequired), }; let actor = header.actor.participant(); diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs b/crates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs @@ -68,7 +68,9 @@ impl MinimumProof { let related: Option<Vec<u8>> = row .try_get(2) .map_err(|_| OperationError::RecoveryRequired)?; - if !(0..=if catalog >= 17 { + if !(0..=if catalog >= 18 { + 14 + } else if catalog >= 17 { 12 } else if catalog >= 16 { 10 @@ -108,6 +110,22 @@ impl MinimumProof { .await?, ); } + if family == 13 { + hash.update( + super::super::envelope::raw_admission_projection( + connection, &actor, &operation, + ) + .await?, + ); + } + if family == 14 { + hash.update( + super::super::envelope::raw_rewrap_projection( + connection, &actor, &operation, + ) + .await?, + ); + } if family == 7 { hash.update( super::abort::raw_projection(connection, &actor, &operation).await?, @@ -169,7 +187,7 @@ pub(in crate::workspace::stock) async fn authenticate_order_state( authority: &Authority, order: radroots_domain::OrderId, ) -> Result<super::super::order_state::Checked, OperationError> { - if !matches!(authority.catalog, 13..=17) { + if !matches!(authority.catalog, 13..=18) { return Err(OperationError::UnsupportedOperation); } let current = authority @@ -238,7 +256,7 @@ pub(super) async fn authenticate_order_absence( let current = authority .inventory .ok_or(OperationError::UnsupportedOperation)?; - if !matches!(authority.catalog, 9..=17) { + if !matches!(authority.catalog, 9..=18) { return Err(OperationError::UnsupportedOperation); } let upper = current.revision.get(); @@ -320,7 +338,7 @@ pub(in crate::workspace::stock) async fn authenticate_identity( let current = authority .inventory .ok_or(OperationError::UnsupportedOperation)?; - let multipart = matches!(authority.catalog, 7..=17); + let multipart = matches!(authority.catalog, 7..=18); let upper = current.revision.get(); let mut previous = current.head; let mut hash = history_hash(multipart); @@ -497,7 +515,7 @@ pub(in crate::workspace::stock) async fn authenticate_minimum_with_local( minimum.revision().get().max(1) }; let upper = current.revision.get(); - let multipart = matches!(authority.catalog, 7..=17); + let multipart = matches!(authority.catalog, 7..=18); let mut hash = history_hash(multipart); let mut expected = current.head; for revision in (lower..=upper).rev() { @@ -761,7 +779,7 @@ async fn authenticate_projected( .ok_or(OperationError::UnsupportedOperation)?; let upper = current.revision.get(); let mut expected = current.head; - let multipart = matches!(authority.catalog, 7..=17); + let multipart = matches!(authority.catalog, 7..=18); let mut hash = history_hash(multipart); for revision in (1..=upper).rev() { let id:Vec<u8>=sqlx::query_scalar("SELECT operation_id FROM stock_operations WHERE revision=? AND length(operation_id)=32").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs @@ -120,7 +120,7 @@ pub(super) fn encode_operation( String::from_utf8(clear.to_vec()).map_err(|_| OperationError::StorageFailure)?, ) .map_err(|_| OperationError::StorageFailure)?; - if matches!(catalog, 5..=17) { + if matches!(catalog, 5..=18) { return super::encode(&OperationV4 { version: 4, authorization: authorization.ok_or(OperationError::RecoveryRequired)?, @@ -158,7 +158,7 @@ fn decode_inner( catalog: i64, allow_mapping: bool, ) -> Result<(InventoryRequest, OperationData), OperationError> { - if matches!(catalog, 5..=17) { + if matches!(catalog, 5..=18) { let decoded: OperationV4<'_> = super::closed_record(bytes).map_err(|_| OperationError::RecoveryRequired)?; if decoded.version != 4 { diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/installation.rs b/crates/storage_sqlite/src/workspace/stock/inventory/installation.rs @@ -222,7 +222,7 @@ pub(in crate::workspace) async fn install( &proof, )) .await?; - if !matches!(auth.access.authority.catalog, 12..=17) { + if !matches!(auth.access.authority.catalog, 12..=18) { return Err(OperationError::UnsupportedOperation); } let (old, identity) = Box::pin(existing(turn, &auth, request.operation)).await?; @@ -481,7 +481,7 @@ pub(in crate::workspace) async fn read( &proof, )) .await?; - if !matches!(auth.access.authority.catalog, 12..=17) { + if !matches!(auth.access.authority.catalog, 12..=18) { return Err(OperationError::UnsupportedOperation); } let (retained, identity) = Box::pin(existing(turn, &auth, request.operation)).await?; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/mapping.rs b/crates/storage_sqlite/src/workspace/stock/inventory/mapping.rs @@ -58,7 +58,7 @@ impl MappingRead { } } pub(super) fn require(access: &Access, key: OptionMappingKey) -> Result<(), OperationError> { - if !(5..=17).contains(&access.authority.catalog) { + if !(5..=18).contains(&access.authority.catalog) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs b/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs @@ -3,7 +3,7 @@ use super::*; pub(super) fn record_version(catalog: i64) -> Result<u8, OperationError> { match catalog { 2 => Ok(1), - 3..=17 => Ok(2), + 3..=18 => Ok(2), _ => Err(OperationError::RecoveryRequired), } } diff --git a/crates/storage_sqlite/src/workspace/stock/issuance/recovery.rs b/crates/storage_sqlite/src/workspace/stock/issuance/recovery.rs @@ -81,7 +81,7 @@ pub(in crate::workspace) async fn authorize( &proof, )) .await?; - if !matches!(auth.access.authority.catalog, 13..=17) { + if !matches!(auth.access.authority.catalog, 13..=18) { return Err(OperationError::UnsupportedOperation); } let plan = auth.plan.as_ref().ok_or(OperationError::StaleState)?; diff --git a/crates/storage_sqlite/src/workspace/stock/issuance/unissued.rs b/crates/storage_sqlite/src/workspace/stock/issuance/unissued.rs @@ -339,7 +339,7 @@ pub(in crate::workspace) async fn capture( } let (authority, record, root, grant) = super::super::read(turn.connection, input, turn.crypto).await?; - if !matches!(authority.catalog, 14..=17) { + if !matches!(authority.catalog, 14..=18) { return Err(OperationError::UnsupportedOperation); } record.authenticate_retained_capture(input, &proof)?; @@ -493,7 +493,7 @@ pub(in crate::workspace) async fn read( &proof, ) .await?; - if !matches!(auth.access.authority.catalog, 14..=17) { + if !matches!(auth.access.authority.catalog, 14..=18) { return Err(OperationError::UnsupportedOperation); } let witness = Box::pin(checkpoint::authenticate_minimum( diff --git a/crates/storage_sqlite/src/workspace/stock/ledger.rs b/crates/storage_sqlite/src/workspace/stock/ledger.rs @@ -28,6 +28,8 @@ pub(super) enum Family { Envelope, DeliveryAttempt, DeliveryObservation, + RewrapAdmission, + RewrappedEnvelope, } #[derive(Serialize, Deserialize)] @@ -87,6 +89,8 @@ impl Header { | Family::Envelope | Family::DeliveryAttempt | Family::DeliveryObservation + | Family::RewrappedEnvelope + | Family::RewrapAdmission ) != self.related_operation.is_some() || (self.family == Family::Consent) != self.subject_grant.is_some() || self.bytes == 0 @@ -346,6 +350,8 @@ impl Family { Self::Envelope => 10, Self::DeliveryAttempt => 11, Self::DeliveryObservation => 12, + Self::RewrapAdmission => 13, + Self::RewrappedEnvelope => 14, } } } @@ -503,14 +509,14 @@ pub(super) async fn history( )) .await } - Some(2) if matches!(authority.catalog, 9..=17) => { + Some(2) if matches!(authority.catalog, 9..=18) => { Box::pin(history_family_2( connection, input, crypto, binding, authority, operation, )) .await } Some(2) => Err(OperationError::UnsupportedOperation), - Some(3) if matches!(authority.catalog, 10..=17) => { + Some(3) if matches!(authority.catalog, 10..=18) => { Box::pin(history_family_3( connection, input, crypto, binding, authority, operation, )) @@ -528,7 +534,7 @@ pub(super) async fn history( )) .await } - Some(6) if matches!(authority.catalog, 12..=17) => { + Some(6) if matches!(authority.catalog, 12..=18) => { Box::pin(history_family_6( connection, input, crypto, binding, authority, operation, )) @@ -558,6 +564,18 @@ pub(super) async fn history( )) .await } + Some(13) if authority.catalog >= 18 => Ok(Some( + Box::pin(super::envelope::admission_history( + connection, input, crypto, binding, operation, + )) + .await?, + )), + Some(14) if authority.catalog >= 18 => { + Box::pin(history_family_10( + connection, input, crypto, binding, authority, operation, + )) + .await + } Some(_) => Err(OperationError::RecoveryRequired), } } @@ -937,10 +955,19 @@ impl HistoryEntry { (_, None) => {} } match (header.family, self.envelope) { - (Family::Envelope, Some(projection)) => { + (Family::Envelope, Some(projection @ super::envelope::Projection::Original { .. })) => { hash.update(projection.digest(header.actor.participant(), header.operation)) } - (Family::Envelope, None) | (_, Some(_)) => { + ( + Family::RewrapAdmission, + Some(projection @ super::envelope::Projection::Admission { .. }), + ) => hash.update(projection.digest(header.actor.participant(), header.operation)), + ( + Family::RewrappedEnvelope, + Some(projection @ super::envelope::Projection::Rewrap { .. }), + ) => hash.update(projection.digest(header.actor.participant(), header.operation)), + (Family::Envelope | Family::RewrapAdmission | Family::RewrappedEnvelope, _) + | (_, Some(_)) => { return Err(OperationError::RecoveryRequired); } (_, None) => {} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/abort_failures_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/abort_failures_tests.rs @@ -120,9 +120,7 @@ async fn late_order_grant_pool_and_unrelated_preparation_changes_never_commit_a_ .fetch_one(&mut raw) .await .unwrap(); - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .abort_proven_unissued(selected, r.enrollment.proof()), @@ -277,9 +275,7 @@ async fn losing_abort_observer_drains_original_admitted_work_before_reopen() { let (_, receipt) = Box::pin(prepared(&r)).await; let provider = reopen(&mut r).await; let selected = abort_request(&r, &receipt).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .abort_proven_unissued(selected, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/acceptance_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/acceptance_tests.rs @@ -448,9 +448,7 @@ async fn lost_observer_retains_actual_two_pool_preparation_and_drain_precedes_re consent(&r, &command).await; let request = request(&r, &command).await; let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .prepare_stock_acceptance(request, r.enrollment.proof()), @@ -502,9 +500,7 @@ async fn source_mapping_pool_order_and_grant_rows_are_rechecked_after_final_prov let request = request(&r, &command).await; let provider = reopen(&mut r).await; let mut raw = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .prepare_stock_acceptance(request, r.enrollment.proof()), @@ -539,9 +535,7 @@ async fn final_clock_recheck_refuses_expiry_and_rollback_after_protection_withou consent(&r, &command).await; let request = request(&r, &command).await; let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .prepare_stock_acceptance(request, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/claim_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/claim_tests.rs @@ -327,9 +327,7 @@ async fn lost_claim_observer_drains_and_reopens_as_existing_without_a_permit() { let recipient = receipt.rumor().recipients()[0]; let request = selector(&r, &receipt, recipient).await; let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .claim_stock_signing_attempt(request, r.enrollment.proof()), @@ -404,9 +402,7 @@ async fn claim_rechecks_original_plan_projection_grant_root_and_clock_after_prov let request = selector(&r, &receipt, recipient).await; let provider = reopen(&mut r).await; let mut raw = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .claim_stock_signing_attempt(request, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/claimed_abort_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/claimed_abort_tests.rs @@ -398,9 +398,7 @@ async fn lost_claimed_cleanup_waiter_drains_before_reopen_and_keeps_original_pro refused(&r, &receipt, peer(&r, &receipt), true).await; let request = abort_request(&r, &receipt).await; let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin(r.store.abort_proven_unissued(request, r.enrollment.proof())); assert!(futures::poll!(pending.as_mut()).is_pending()); provider.gate.entered(); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/delivery_boundaries_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/delivery_boundaries_tests.rs @@ -127,9 +127,7 @@ async fn late_extra_projection_cannot_cross_the_final_attempt_transaction() { let selected = request(&r, &original, &outer, 21).await; let provider = reopen(&mut r).await; let mut db = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin(r.store.prepare_stock_delivery_attempt(selected, proof(&r))); assert!(futures::poll!(pending.as_mut()).is_pending()); provider.gate.entered(); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/delivery_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/delivery_tests.rs @@ -26,7 +26,7 @@ fn intent(outer: &PrivateEnvelopeCandidate, request: u8) -> DeliveryIntent { ) .unwrap() } -async fn request( +pub(super) async fn request( r: &Rig, original: &StockAcceptanceReceipt, outer: &PrivateEnvelopeCandidate, @@ -42,7 +42,7 @@ async fn request( ) .unwrap() } -async fn claim( +pub(super) async fn claim( r: &Rig, original: &StockAcceptanceReceipt, outer: &PrivateEnvelopeCandidate, @@ -58,7 +58,7 @@ async fn claim( }; value } -fn observed( +pub(super) fn observed( attempt: &StockDeliveryAttempt, outcome: DeliveryOutcome, at: Option<NonZeroU64>, @@ -70,7 +70,10 @@ fn observed( ) .unwrap() } -async fn save(r: &Rig, observation: &StockDeliveryObservation) -> StockDeliveryObservationReceipt { +pub(super) async fn save( + r: &Rig, + observation: &StockDeliveryObservation, +) -> StockDeliveryObservationReceipt { let StockDeliveryObservationOutcome::Committed(receipt) = r .store .record_stock_delivery_observation(&r.binding, r.enrollment.proof(), observation) diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/envelope_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/envelope_tests.rs @@ -9,6 +9,8 @@ use radroots_storage::{ use std::num::NonZeroU64; #[path = "delivery_tests.rs"] mod delivery_tests; +#[path = "rewrap_tests.rs"] +mod rewrapping; fn proof(r: &Rig) -> AttachmentProof { r.enrollment .proof() @@ -290,9 +292,7 @@ async fn late_original_or_projection_damage_cannot_commit_a_partially_authentica let selected = envelope_request(&r, &original, outer.recipient(), None).await; let provider = reopen(&mut r).await; let mut db = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin(r.store.capture_stock_envelope(selected, proof(&r), &outer)); assert!(futures::poll!(pending.as_mut()).is_pending()); provider.gate.entered(); @@ -428,9 +428,7 @@ async fn lost_outer_observer_is_drained_and_one_exact_record_survives_reopen() { let (mut r, original, _, outer) = setup(17).await; let selected = envelope_request(&r, &original, outer.recipient(), None).await; let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin(r.store.capture_stock_envelope(selected, proof(&r), &outer)); assert!(futures::poll!(pending.as_mut()).is_pending()); provider.gate.entered(); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/evidence_reconciliation_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/evidence_reconciliation_tests.rs @@ -128,7 +128,7 @@ async fn refused_stock_recovery_preflight_keeps_writer_and_cached_original_autho remove_fault(&mut database, true).await; provider .gate - .arm(Direction::Unwrap, "radroots.seller_stock.authority.v17", 0); + .arm(Direction::Unwrap, r.authority_schema(), 0); let mut recovery = Box::pin(reconcile(&r, &request)); assert!(futures::poll!(recovery.as_mut()).is_pending()); provider.gate.entered(); @@ -184,7 +184,7 @@ async fn lost_reconciliation_observer_drains_the_actual_replacement_and_original remove_fault(&mut database, true).await; provider .gate - .arm(Direction::Unwrap, "radroots.seller_stock.authority.v17", 0); + .arm(Direction::Unwrap, r.authority_schema(), 0); let mut recovery = Box::pin(reconcile(&r, &request)); assert!(futures::poll!(recovery.as_mut()).is_pending()); provider.gate.entered(); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/evidence_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/evidence_tests.rs @@ -444,9 +444,7 @@ async fn lost_capture_observer_drains_owned_input_and_reopens_the_exact_original let (report, raw) = obtained(&r, &receipt, recipient).await; let evidence = StockEvidenceCapture::verify(r.binding.clone(), &report, &raw, None).unwrap(); let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .capture_stock_signing_evidence(&evidence, r.enrollment.proof()), @@ -532,9 +530,7 @@ async fn capture_rechecks_original_claim_plan_root_and_grant_after_provider_io() StockEvidenceCapture::verify(r.binding.clone(), &report, &raw, None).unwrap(); let provider = reopen(&mut r).await; let mut rawdb = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .capture_stock_signing_evidence(&evidence, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/exact_recovery_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/exact_recovery_tests.rs @@ -437,7 +437,7 @@ async fn replay_authorization_rechecks_actual_late_root_grant_plan_claim_backing let mut raw = database(&r).await; provider .gate - .arm(Direction::Unwrap, "radroots.seller_stock.authority.v17", 0); + .arm(Direction::Unwrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .authorize_stock_exact_replay(request, r.enrollment.proof()), @@ -491,7 +491,7 @@ async fn observer_loss_drains_authorization_without_signing_or_a_new_claim_and_r let provider = reopen(&mut r).await; provider .gate - .arm(Direction::Unwrap, "radroots.seller_stock.authority.v17", 0); + .arm(Direction::Unwrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .authorize_stock_exact_replay(request, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/installation_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/installation_tests.rs @@ -412,9 +412,7 @@ async fn lost_t2_observer_drains_and_reopens_one_atomic_installation() { retain(&r, &receipt, peer(&r, &receipt)).await; let selected = request(&r, &receipt).await; let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .install_stock_agreement(selected, r.enrollment.proof()), @@ -451,9 +449,7 @@ async fn late_t2_backing_or_grant_or_evidence_change_never_commits_partial_insta let selected = request(&r, &receipt).await; let provider = reopen(&mut r).await; let mut db = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .install_stock_agreement(selected, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/process_death_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/process_death_tests.rs @@ -18,6 +18,8 @@ const BARRIER: &str = "RADROOTS_STOCK_PROCESS_BOUNDARY_V1"; const CHILD: &str = "workspace::stock::public_source::tests::provider::history::acceptance::signing::claims::evidence::installations::process_death::stock_process_child"; #[path = "process_delivery_tests.rs"] mod delivery; +#[path = "process_rewrap_tests.rs"] +mod rewrap; #[derive(Clone, Copy, Debug, serde::Serialize, serde::Deserialize)] enum Edge { @@ -27,6 +29,10 @@ enum Edge { Envelope, Delivery, Observation, + RewrapAdmission, + RewrapEnvelope, + RewrapDelivery, + RewrapObservation, } #[derive(serde::Serialize, serde::Deserialize)] #[serde(deny_unknown_fields)] @@ -41,6 +47,7 @@ struct Control { edge: Edge, before: bool, delivery_transaction: Option<TransactionId>, + rewrap: Option<rewrap::Original>, } struct KillOnDrop(Child); impl Drop for KillOnDrop { @@ -107,10 +114,10 @@ async fn stock_process_child() { let mut bytes = Vec::new(); std::fs::File::open(root.join("stock-process-control.json")) .unwrap() - .take(73729) + .take(147457) .read_to_end(&mut bytes) .unwrap(); - assert!(bytes.len() <= 73728); + assert!(bytes.len() <= 147456); let control: Control = serde_json::from_slice(&bytes).unwrap(); let file = Arc::new( FileProvider::open( @@ -156,7 +163,14 @@ async fn stock_process_child() { .unwrap(); let capture = if matches!( control.edge, - Edge::Abort | Edge::Envelope | Edge::Delivery | Edge::Observation + Edge::Abort + | Edge::Envelope + | Edge::Delivery + | Edge::Observation + | Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation ) { None } else { @@ -177,9 +191,13 @@ async fn stock_process_child() { Some(StockEvidenceCapture::verify(binding.clone(), &report, &control.raw, None).unwrap()) }; if control.before { - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm( + Direction::Wrap, + crate::workspace::stock::tests::catalog_authority_schema( + crate::workspace::stock::schema::CURRENT, + ), + 0, + ); } let work = async { match control.edge { @@ -253,7 +271,10 @@ async fn stock_process_child() { .unwrap(), ); } - Edge::Delivery | Edge::Observation => { + Edge::RewrapAdmission | Edge::RewrapEnvelope => { + return Some(rewrap::apply(&store, binding, minimum, &proof, &control).await); + } + Edge::Delivery | Edge::Observation | Edge::RewrapDelivery | Edge::RewrapObservation => { return Some(delivery::apply(&store, binding, minimum, &proof, &control).await); } } @@ -288,6 +309,10 @@ async fn process_death_before_and_after_confirmed_stock_writes_preserves_origina Edge::Envelope, Edge::Delivery, Edge::Observation, + Edge::RewrapAdmission, + Edge::RewrapEnvelope, + Edge::RewrapDelivery, + Edge::RewrapObservation, ] { for before in [true, false] { println!("stock boundary {edge:?} before={before}"); @@ -306,7 +331,14 @@ async fn process_death_before_and_after_confirmed_stock_writes_preserves_origina }; if matches!( edge, - Edge::Install | Edge::Envelope | Edge::Delivery | Edge::Observation + Edge::Install + | Edge::Envelope + | Edge::Delivery + | Edge::Observation + | Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation ) { let capture = StockEvidenceCapture::verify( r.binding.clone(), @@ -322,21 +354,29 @@ async fn process_death_before_and_after_confirmed_stock_writes_preserves_origina .unwrap(), ); } - let wrapping_key = - if matches!(edge, Edge::Envelope | Edge::Delivery | Edge::Observation) { - installed(install(&r, &receipt).await.unwrap()); - let pending = radroots_nostr::signing::gift_wrap::wrap_retained_seal( - &raw, - recipient, - std::num::NonZeroU64::new(150).unwrap(), - &radroots_nostr::signing::OsNonceSource, - ) - .unwrap(); - raw = pending.signed_json().to_owned(); - Some(pending.with_wrapping_key(|key| *key)) - } else { - None - }; + let wrapping_key = if matches!( + edge, + Edge::Envelope + | Edge::Delivery + | Edge::Observation + | Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation + ) { + installed(install(&r, &receipt).await.unwrap()); + let pending = radroots_nostr::signing::gift_wrap::wrap_retained_seal( + &raw, + recipient, + std::num::NonZeroU64::new(150).unwrap(), + &radroots_nostr::signing::OsNonceSource, + ) + .unwrap(); + raw = pending.signed_json().to_owned(); + Some(pending.with_wrapping_key(|key| *key)) + } else { + None + }; let mut control = Control { input: r.enrollment.input().clone(), proof: r.enrollment.proof().with_secret(|bytes| bytes.to_vec()), @@ -348,10 +388,20 @@ async fn process_death_before_and_after_confirmed_stock_writes_preserves_origina edge, before, delivery_transaction: None, + rewrap: None, }; if matches!(edge, Edge::Delivery | Edge::Observation) { control.delivery_transaction = Box::pin(delivery::prepare(&r, &control)).await; } + if matches!( + edge, + Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation + ) { + Box::pin(rewrap::prepare(&r, &mut control)).await; + } let minimum = inventory_minimum(&r).await; let mut file = std::fs::OpenOptions::new() .create_new(true) @@ -398,12 +448,26 @@ async fn process_death_before_and_after_confirmed_stock_writes_preserves_origina .unwrap(); let has_evidence = matches!( edge, - Edge::Install | Edge::Envelope | Edge::Delivery | Edge::Observation + Edge::Install + | Edge::Envelope + | Edge::Delivery + | Edge::Observation + | Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation ) || (matches!(edge, Edge::Capture) && !before); assert_eq!(peer.first_evidence().is_some(), has_evidence); - let has_installation = - matches!(edge, Edge::Envelope | Edge::Delivery | Edge::Observation) - || (matches!(edge, Edge::Install) && !before); + let has_installation = matches!( + edge, + Edge::Envelope + | Edge::Delivery + | Edge::Observation + | Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation + ) || (matches!(edge, Edge::Install) && !before); assert_eq!(snapshot.installation().is_some(), has_installation); let has_abort = matches!(edge, Edge::Abort) && !before; assert_eq!(snapshot.aborted().is_some(), has_abort); @@ -425,6 +489,15 @@ async fn process_death_before_and_after_confirmed_stock_writes_preserves_origina balances(&r, 81, 8, 2, 0, 2).await; } assert_eq!(inventory_minimum(&r).await, current); + if matches!( + edge, + Edge::RewrapAdmission + | Edge::RewrapEnvelope + | Edge::RewrapDelivery + | Edge::RewrapObservation + ) { + Box::pin(rewrap::verify(&r, &control, transaction)).await; + } if matches!(edge, Edge::Delivery | Edge::Observation) { Box::pin(delivery::verify(&r, &control, transaction)).await; } diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/process_delivery_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/process_delivery_tests.rs @@ -11,7 +11,7 @@ use radroots_transport::{ sink::DeliveryTargetReceipt, }; -fn candidate(c: &Control) -> PrivateEnvelopeCandidate { +pub(super) fn candidate(c: &Control) -> PrivateEnvelopeCandidate { PrivateEnvelopeCandidate::from_obtained(c.recipient, &c.raw, &c.wrapping_key.unwrap()).unwrap() } fn intent(c: &Control) -> DeliveryIntent { @@ -24,19 +24,26 @@ fn intent(c: &Control) -> DeliveryIntent { ) .unwrap() } -fn source( +pub(super) fn source( binding: radroots_storage::workspace::WorkspaceBinding, minimum: InventoryCheckpointRef, c: &Control, ) -> StockEnvelopeRequest { - StockEnvelopeRequest::new(binding, minimum, c.operation, c.digest, c.recipient, None).unwrap() + let request = + StockEnvelopeRequest::new(binding, minimum, c.operation, c.digest, c.recipient, None) + .unwrap(); + if c.rewrap.is_some() { + request.with_envelope(candidate(c).event_id()) + } else { + request + } } -fn request( +pub(super) fn request( binding: radroots_storage::workspace::WorkspaceBinding, minimum: InventoryCheckpointRef, c: &Control, ) -> StockDeliveryRequest { - StockDeliveryRequest::new( + let request = StockDeliveryRequest::new( binding, minimum, c.operation, @@ -44,7 +51,12 @@ fn request( c.recipient, intent(c), ) - .unwrap() + .unwrap(); + if c.rewrap.is_some() { + request.with_envelope(candidate(c).event_id()).unwrap() + } else { + request + } } fn observation( attempt: &StockDeliveryAttempt, @@ -72,7 +84,7 @@ pub(super) async fn prepare(r: &Rig, c: &Control) -> Option<TransactionId> { .unwrap(), StockEnvelopeOutcome::Committed(_) )); - if matches!(c.edge, Edge::Observation) { + if matches!(c.edge, Edge::Observation | Edge::RewrapObservation) { let StockDeliveryAttemptOutcome::Claimed(attempt) = r .store .prepare_stock_delivery_attempt( @@ -99,7 +111,7 @@ pub(super) async fn apply( proof: &AttachmentProof, c: &Control, ) -> TransactionId { - if matches!(c.edge, Edge::Delivery) { + if matches!(c.edge, Edge::Delivery | Edge::RewrapDelivery) { let StockDeliveryAttemptOutcome::Claimed(attempt) = store .prepare_stock_delivery_attempt( request(binding, minimum, c), @@ -169,7 +181,7 @@ pub(super) async fn verify(r: &Rig, c: &Control, transaction: Option<Transaction .unwrap(); assert_eq!( loaded.is_some(), - matches!(c.edge, Edge::Observation) || !c.before + matches!(c.edge, Edge::Observation | Edge::RewrapObservation) || !c.before ); assert_eq!(transaction.is_some(), !c.before); let has_attempt = loaded.is_some(); @@ -178,7 +190,7 @@ pub(super) async fn verify(r: &Rig, c: &Control, transaction: Option<Transaction assert_eq!(attempt.intent(), &intent(c)); assert_eq!( Some(attempt.transaction_id()), - if matches!(c.edge, Edge::Delivery) { + if matches!(c.edge, Edge::Delivery | Edge::RewrapDelivery) { transaction } else { c.delivery_transaction @@ -213,7 +225,7 @@ pub(super) async fn verify(r: &Rig, c: &Control, transaction: Option<Transaction .await .unwrap(); assert!(page.next_after().is_none()); - let confirmed = matches!(c.edge, Edge::Observation) && !c.before; + let confirmed = matches!(c.edge, Edge::Observation | Edge::RewrapObservation) && !c.before; assert_eq!(page.entries().len(), usize::from(confirmed)); if confirmed { let original = &page.entries()[0]; @@ -282,7 +294,7 @@ pub(super) async fn verify(r: &Rig, c: &Control, transaction: Option<Transaction assert_eq!(summary.attempt_count(), u16::from(has_attempt)); assert_eq!( summary.acceptance_satisfied().unwrap(), - matches!(c.edge, Edge::Observation) && !c.before + matches!(c.edge, Edge::Observation | Edge::RewrapObservation) && !c.before ); if has_attempt { assert_eq!(summary.targets()[0].potential_attempts(), 1); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/process_rewrap_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/process_rewrap_tests.rs @@ -0,0 +1,281 @@ +//! Private F13/F14 process boundaries reuse the actual native owner and keys. +use super::*; +use radroots_domain::EnvelopeEventId; +use radroots_storage::{command::PrivateEnvelopeCandidate, inventory::*}; +use sha2::{Digest, Sha256}; +#[derive(serde::Serialize, serde::Deserialize)] +#[serde(deny_unknown_fields)] +pub(super) struct Original { + id: OperationId, + event: EnvelopeEventId, + transaction: TransactionId, + digest: [u8; 32], +} +fn base( + binding: radroots_storage::workspace::WorkspaceBinding, + minimum: InventoryCheckpointRef, + c: &Control, +) -> StockEnvelopeRequest { + StockEnvelopeRequest::new(binding, minimum, c.operation, c.digest, c.recipient, None).unwrap() +} +fn request( + binding: radroots_storage::workspace::WorkspaceBinding, + minimum: InventoryCheckpointRef, + c: &Control, + selected: bool, +) -> StockRewrapRequest { + let request = StockRewrapRequest::new(base(binding, minimum, c), c.rewrap.as_ref().unwrap().id); + if selected { + request.with_envelope(delivery::candidate(c).event_id()) + } else { + request + } +} +fn proof(r: &Rig) -> AttachmentProof { + r.enrollment + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap() +} +pub(super) async fn prepare(r: &Rig, c: &mut Control) { + let StockEnvelopeOutcome::Committed(first) = r + .store + .capture_stock_envelope( + base(r.binding.clone(), inventory_minimum(r).await, c), + proof(r), + &delivery::candidate(c), + ) + .await + .unwrap() + else { + panic!("original F10 required") + }; + c.rewrap = Some(Original { + id: OperationId::from_bytes([28; 32]), + event: first.event_id(), + transaction: first.attempt().transaction_id().unwrap(), + digest: *first.digest(), + }); + if matches!(c.edge, Edge::RewrapAdmission) { + return; + } + assert!(matches!( + r.store + .prepare_stock_rewrap( + request(r.binding.clone(), inventory_minimum(r).await, c, false), + proof(r) + ) + .await + .unwrap(), + StockRewrapOutcome::Claimed(_) + )); + let source = r + .store + .stock_signing_evidence( + StockClaimRequest::new( + r.binding.clone(), + inventory_minimum(r).await, + c.operation, + c.digest, + c.recipient, + ), + *first.evidence().digest(), + r.enrollment.proof(), + ) + .await + .unwrap() + .unwrap(); + let wrapped = source.with_json(|raw| { + radroots_nostr::signing::gift_wrap::wrap_retained_seal( + raw, + c.recipient, + std::num::NonZeroU64::new(150).unwrap(), + &radroots_nostr::signing::OsNonceSource, + ) + .unwrap() + }); + c.raw = wrapped.signed_json().to_owned(); + c.wrapping_key = Some(wrapped.with_wrapping_key(|key| *key)); + assert_ne!(delivery::candidate(c).event_id(), first.event_id()); + if matches!(c.edge, Edge::RewrapEnvelope) { + return; + } + assert!(matches!( + r.store + .capture_stock_rewrap( + request(r.binding.clone(), inventory_minimum(r).await, c, true), + proof(r), + &delivery::candidate(c) + ) + .await + .unwrap(), + StockEnvelopeOutcome::Committed(_) + )); + if matches!(c.edge, Edge::RewrapObservation) { + let StockDeliveryAttemptOutcome::Claimed(attempt) = r + .store + .prepare_stock_delivery_attempt( + delivery::request(r.binding.clone(), inventory_minimum(r).await, c), + proof(r), + ) + .await + .unwrap() + else { + panic!("selected D required") + }; + c.delivery_transaction = Some(attempt.transaction_id()); + } +} +pub(super) async fn apply( + store: &NativeWorkspace, + binding: radroots_storage::workspace::WorkspaceBinding, + minimum: InventoryCheckpointRef, + proof: &AttachmentProof, + c: &Control, +) -> TransactionId { + let credential = proof + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap(); + match c.edge { + Edge::RewrapAdmission => { + let StockRewrapOutcome::Claimed(admitted) = store + .prepare_stock_rewrap(request(binding, minimum, c, false), credential) + .await + .unwrap() + else { + panic!("new confirmed admission required") + }; + admitted.transaction_id() + } + Edge::RewrapEnvelope => { + let candidate: PrivateEnvelopeCandidate = delivery::candidate(c); + let StockEnvelopeOutcome::Committed(saved) = store + .capture_stock_rewrap(request(binding, minimum, c, true), credential, &candidate) + .await + .unwrap() + else { + panic!("confirmed additional outer required") + }; + saved.attempt().transaction_id().unwrap() + } + _ => unreachable!(), + } +} +pub(super) async fn verify(r: &Rig, c: &Control, transaction: Option<TransactionId>) { + let original = c.rewrap.as_ref().unwrap(); + let first = r + .store + .stock_envelope( + base(r.binding.clone(), inventory_minimum(r).await, c), + proof(r), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(first.receipt().event_id(), original.event); + assert_eq!( + first.receipt().attempt().transaction_id(), + Some(original.transaction) + ); + first.with_json(|raw| { + assert_eq!( + <[u8; 32]>::from(Sha256::digest(raw.as_bytes())), + original.digest + ) + }); + let state = r + .store + .stock_rewrap_attempt( + request(r.binding.clone(), inventory_minimum(r).await, c, false), + proof(r), + ) + .await + .unwrap(); + if matches!(c.edge, Edge::RewrapAdmission) { + assert_eq!(state.is_some(), !c.before); + assert_eq!(transaction.is_some(), !c.before); + if let Some(state) = state { + assert!(state.envelope().is_none()); + assert_eq!(Some(state.admission().transaction_id()), transaction); + let StockRewrapOutcome::Retained(repeated) = r + .store + .prepare_stock_rewrap( + request(r.binding.clone(), inventory_minimum(r).await, c, false), + proof(r), + ) + .await + .unwrap() + else { + panic!("reopened admission grants no wrapping") + }; + assert_eq!(*repeated, state.admission()); + } + } else if matches!(c.edge, Edge::RewrapEnvelope) { + let state = state.unwrap(); + assert_eq!(state.envelope().is_some(), !c.before); + assert_eq!( + state.envelope().and_then(|v| v.attempt().transaction_id()), + transaction + ); + let StockEnvelopeOutcome::Committed(saved) = r + .store + .reconcile_stock_rewrap( + request(r.binding.clone(), inventory_minimum(r).await, c, true), + proof(r), + &delivery::candidate(c), + ) + .await + .unwrap() + else { + panic!("original obtained outer must reconcile") + }; + assert_eq!( + saved.rewrap_admission_transaction_id(), + Some(state.admission().transaction_id()) + ); + if let Some(original) = state.envelope() { + assert_eq!(*saved, original); + } + let found = r + .store + .stock_envelope( + delivery::source(r.binding.clone(), inventory_minimum(r).await, c), + proof(r), + ) + .await + .unwrap() + .unwrap(); + found.with_json(|raw| assert_eq!(raw, c.raw)); + assert_eq!(found.receipt(), *saved); + } else { + delivery::verify(r, c, transaction).await; + let summary = r + .store + .stock_delivery_summary( + base(r.binding.clone(), inventory_minimum(r).await, c), + proof(r), + ) + .await + .unwrap(); + assert!(!summary.acceptance_satisfied().unwrap()); + } + let first = r + .store + .stock_envelope( + base(r.binding.clone(), inventory_minimum(r).await, c), + proof(r), + ) + .await + .unwrap() + .unwrap(); + assert_eq!( + first.receipt().attempt().transaction_id(), + Some(original.transaction) + ); + first.with_json(|raw| { + assert_eq!( + <[u8; 32]>::from(Sha256::digest(raw.as_bytes())), + original.digest + ) + }); +} 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 @@ -0,0 +1,848 @@ +//! Actual additional-envelope transactions preserve original stock commitments. +use super::delivery_tests::{claim as delivery_claim, observed, request as delivery_request, save}; +use super::*; +use radroots_storage::inventory::{ + StockDeliveryAttemptOutcome, StockRewrapAdmission, StockRewrapOutcome, StockRewrapRequest, + StockRewrapState, +}; +struct Additional { + outer: PrivateEnvelopeCandidate, + admission: Option<StockRewrapAdmission>, + id: OperationId, +} +impl core::ops::Deref for Additional { + type Target = PrivateEnvelopeCandidate; + fn deref(&self) -> &Self::Target { + &self.outer + } +} +use radroots_transport::outcome::DeliveryOutcome; + +async fn additional( + r: &Rig, + original: &StockAcceptanceReceipt, + first: StockEnvelopeReceipt, +) -> Additional { + let id = OperationId::from_bytes([28; 32]); + let admitted = r + .store + .prepare_stock_rewrap( + StockRewrapRequest::new( + envelope_request(r, original, first.recipient(), None).await, + id, + ), + proof(r), + ) + .await; + let admission = if r.catalog == 18 { + let StockRewrapOutcome::Claimed(admission) = admitted.unwrap() else { + panic!("fresh confirmed admission required before wrapping") + }; + Some(*admission) + } else { + assert!(matches!( + admitted, + Err(OperationError::UnsupportedOperation) + )); + None + }; + let source = r + .store + .stock_signing_evidence( + crate::workspace::StockClaimRequest::new( + r.binding.clone(), + inventory_minimum(r).await, + original.attempt().operation_id(), + original.attempt().command_digest(), + first.recipient(), + ), + *first.evidence().digest(), + r.enrollment.proof(), + ) + .await + .unwrap() + .unwrap(); + Additional { + outer: source.with_json(|raw| wrapped(raw, first.recipient())), + admission, + id, + } +} +async fn selected( + r: &Rig, + original: &StockAcceptanceReceipt, + outer: &PrivateEnvelopeCandidate, +) -> StockEnvelopeRequest { + envelope_request(r, original, outer.recipient(), None) + .await + .with_envelope(outer.event_id()) +} +async fn capture_request( + r: &Rig, + original: &StockAcceptanceReceipt, + new: &Additional, +) -> StockRewrapRequest { + StockRewrapRequest::new(selected(r, original, new).await, new.id) +} +#[tokio::test] +async fn rewrapping_preserves_original_bytes_and_independent_transactions_across_reopen() { + let (mut r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let new = additional(&r, &original, first).await; + assert_ne!(new.event_id(), first.event_id()); + let before = inventory_minimum(&r).await; + let saved = committed_envelope( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await + .unwrap(), + ); + assert_eq!(saved.evidence(), first.evidence()); + assert_eq!( + saved.installation_transaction_id(), + first.installation_transaction_id() + ); + assert_ne!( + saved.attempt().transaction_id(), + first.attempt().transaction_id() + ); + assert_eq!( + saved.checkpoint().revision().get(), + before.revision().get() + 1 + ); + let minimum = inventory_minimum(&r).await; + assert_eq!( + committed_envelope( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await + .unwrap() + ), + saved + ); + assert_eq!(inventory_minimum(&r).await, minimum); + assert!(matches!( + r.store + .capture_stock_envelope(selected(&r, &original, &new).await, proof(&r), &new) + .await, + Err(OperationError::InvalidCommand) + )); + reopen_plain(&mut r).await; + let old = r + .store + .stock_envelope( + envelope_request(&r, &original, outer.recipient(), None).await, + proof(&r), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(old.receipt(), first); + old.with_json(|raw| assert_eq!(raw, outer.raw_json())); + let loaded = r + .store + .stock_envelope(selected(&r, &original, &new).await, proof(&r)) + .await + .unwrap() + .unwrap(); + assert_eq!(loaded.receipt(), saved); + loaded.with_json(|raw| assert_eq!(raw, new.raw_json())); + let page = r + .store + .stock_rewraps( + envelope_request(&r, &original, outer.recipient(), None).await, + None, + proof(&r), + ) + .await + .unwrap(); + assert_eq!( + page.entries(), + &[StockRewrapState::from_store_report(new.admission.unwrap(), Some(saved)).unwrap()] + ); + assert!(page.next_after().is_none()); + balances(&r, 80, 9, 0, 1, 3).await; + balances(&r, 81, 8, 0, 2, 3).await; + assert_eq!(inventory_minimum(&r).await, minimum); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn rewrapping_delivery_preserves_global_policy_and_counters_but_scopes_acceptance_to_each_outer() + { + let (mut r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let initial = delivery_claim(&r, &original, &outer, 1).await; + let initial_observation = + save(&r, &observed(&initial, DeliveryOutcome::accepted(), None)).await; + let new = additional(&r, &original, first).await; + let saved = committed_envelope( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await + .unwrap(), + ); + let request = delivery_request(&r, &original, &new, 2) + .await + .with_envelope(new.event_id()) + .unwrap() + .with_expected_attempt_count(1) + .unwrap(); + let StockDeliveryAttemptOutcome::Claimed(attempt) = r + .store + .prepare_stock_delivery_attempt(request, proof(&r)) + .await + .unwrap() + else { + panic!("fresh confirmed selected D required") + }; + assert_eq!(attempt.target_ordinals(), &[2]); + attempt + .source() + .with_json(|raw| assert_eq!(raw, new.raw_json())); + assert_eq!(attempt.source().receipt(), saved); + let rejected = save(&r, &observed(&attempt, DeliveryOutcome::rejected(), None)).await; + let original_summary = r + .store + .stock_delivery_summary( + envelope_request(&r, &original, outer.recipient(), None).await, + proof(&r), + ) + .await + .unwrap(); + let selected_summary = r + .store + .stock_delivery_summary(selected(&r, &original, &new).await, proof(&r)) + .await + .unwrap(); + assert!(original_summary.acceptance_satisfied().unwrap()); + assert!(!selected_summary.acceptance_satisfied().unwrap()); + assert_eq!(selected_summary.source(), Some(saved)); + assert_eq!(selected_summary.publication_policy_source(), Some(first)); + 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.targets()[0].potential_attempts(), 2); + let accepted = save(&r, &observed(&attempt, DeliveryOutcome::accepted(), None)).await; + let page = r + .store + .stock_delivery_observations(selected(&r, &original, &new).await, None, proof(&r)) + .await + .unwrap(); + assert_eq!(page.entries(), &[rejected, accepted]); + let original_page = r + .store + .stock_delivery_observations( + envelope_request(&r, &original, outer.recipient(), None).await, + None, + proof(&r), + ) + .await + .unwrap(); + assert_eq!(original_page.entries(), &[initial_observation]); + let transaction = attempt.transaction_id(); + reopen_plain(&mut r).await; + let request = delivery_request(&r, &original, &new, 2) + .await + .with_envelope(new.event_id()) + .unwrap(); + let StockDeliveryAttemptOutcome::Retained(existing) = r + .store + .prepare_stock_delivery_attempt(request, proof(&r)) + .await + .unwrap() + else { + panic!("existing selected D cannot authorize another invocation") + }; + assert_eq!(existing.transaction_id(), transaction); + existing + .source() + .with_json(|raw| assert_eq!(raw, new.raw_json())); + let request = delivery_request(&r, &original, &new, 3) + .await + .with_envelope(new.event_id()) + .unwrap() + .with_expected_attempt_count(0) + .unwrap(); + assert!(matches!( + r.store + .prepare_stock_delivery_attempt(request, proof(&r)) + .await, + Err(OperationError::StaleState) + )); + for index in 3..=12 { + let request = delivery_request(&r, &original, &new, index) + .await + .with_envelope(new.event_id()) + .unwrap(); + let StockDeliveryAttemptOutcome::Claimed(value) = r + .store + .prepare_stock_delivery_attempt(request, proof(&r)) + .await + .unwrap() + else { + panic!("new confirmed bounded D required") + }; + assert_eq!(value.target_ordinals(), &[index]); + } + let minimum = inventory_minimum(&r).await; + let request = delivery_request(&r, &original, &new, 13) + .await + .with_envelope(new.event_id()) + .unwrap(); + assert!(matches!( + r.store + .prepare_stock_delivery_attempt(request, proof(&r)) + .await, + Err(OperationError::DeliveryAttemptLimit) + )); + assert_eq!(inventory_minimum(&r).await, minimum); + balances(&r, 80, 9, 0, 1, 3).await; + balances(&r, 81, 8, 0, 2, 3).await; + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn rewrapping_first_delivery_does_not_fabricate_original_envelope_acceptance() { + let (r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let new = additional(&r, &original, first).await; + let saved = committed_envelope( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await + .unwrap(), + ); + let request = delivery_request(&r, &original, &new, 1) + .await + .with_envelope(new.event_id()) + .unwrap(); + let StockDeliveryAttemptOutcome::Claimed(attempt) = r + .store + .prepare_stock_delivery_attempt(request, proof(&r)) + .await + .unwrap() + else { + panic!("new confirmed selected D required") + }; + save(&r, &observed(&attempt, DeliveryOutcome::accepted(), None)).await; + let old = r + .store + .stock_delivery_summary( + envelope_request(&r, &original, outer.recipient(), None).await, + proof(&r), + ) + .await + .unwrap(); + let new_summary = r + .store + .stock_delivery_summary(selected(&r, &original, &new).await, proof(&r)) + .await + .unwrap(); + assert!(!old.acceptance_satisfied().unwrap()); + assert!(new_summary.acceptance_satisfied().unwrap()); + assert_eq!(old.source(), Some(first)); + assert_eq!(old.publication_policy_source(), Some(saved)); + assert_eq!(old.attempt_count(), 1); + let page = r + .store + .stock_delivery_observations( + envelope_request(&r, &original, outer.recipient(), None).await, + None, + proof(&r), + ) + .await + .unwrap(); + assert!(page.entries().is_empty()); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn rewrapping_late_unprotected_index_cannot_cross_final_transaction_witnesses() { + use sqlx::Connection; + let (mut r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let new = additional(&r, &original, first).await; + let request = capture_request(&r, &original, &new).await; + let provider = reopen(&mut r).await; + let mut db = database(&r).await; + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); + let mut pending = Box::pin(r.store.capture_stock_rewrap(request, proof(&r), &new)); + assert!(futures::poll!(pending.as_mut()).is_pending()); + provider.gate.entered(); + sqlx::query("INSERT INTO stock_rewraps(actor,operation_id,recipient,admission_entry,event_id,entry_id) SELECT a.actor,a.operation_id,a.recipient,a.entry_id,?,e.entry_id FROM stock_rewrap_admissions a JOIN stock_envelopes e ON e.actor=a.actor AND e.operation_id=a.operation_id AND e.recipient=a.recipient LIMIT 1") + .bind(new.event_id().as_bytes().as_slice()).execute(&mut db).await.unwrap(); + provider.gate.release(); + assert!(matches!( + pending.await, + Err(OperationError::RecoveryRequired) + )); + let rows: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_operations WHERE family=14") + .fetch_one(&mut db) + .await + .unwrap(); + assert_eq!(rows, 0); + sqlx::query("DELETE FROM stock_rewraps WHERE event_id=?") + .bind(new.event_id().as_bytes().as_slice()) + .execute(&mut db) + .await + .unwrap(); + let request = capture_request(&r, &original, &new).await; + let saved = committed_envelope( + r.store + .reconcile_stock_rewrap(request, proof(&r), &new) + .await + .unwrap(), + ); + assert_eq!(saved.event_id(), new.event_id()); + balances(&r, 80, 9, 0, 1, 3).await; + db.close().await.unwrap(); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn rewrapping_refuses_retained_catalog_seventeen_without_upgrading_it() { + use sqlx::Connection; + let (r, original, _, outer) = setup(17).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let new = additional(&r, &original, first).await; + assert!(matches!( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await, + Err(OperationError::UnsupportedOperation) + )); + let mut db = database(&r).await; + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut db) + .await + .unwrap(); + assert_eq!(catalog, 17); + let table: i64 = + sqlx::query_scalar("SELECT count(*) FROM sqlite_schema WHERE name='stock_rewraps'") + .fetch_one(&mut db) + .await + .unwrap(); + assert_eq!(table, 0); + assert_eq!( + committed_envelope(capture(&r, &original, &outer, None).await.unwrap()), + first + ); + db.close().await.unwrap(); + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn rewrapping_retains_borrowed_original_through_statement_and_commit_failure_and_clock_loss() +{ + use sqlx::Connection; + for uncertain in [false, true] { + let (r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let new = additional(&r, &original, first).await; + let request = capture_request(&r, &original, &new).await; + let mut fault = database(&r).await; + if uncertain { + sqlx::raw_sql("CREATE TABLE rewrap_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER rewrap_fault AFTER INSERT ON stock_rewraps BEGIN INSERT INTO rewrap_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap(); + assert!(matches!( + r.store + .capture_stock_rewrap(request, proof(&r), &new) + .await + .unwrap(), + StockEnvelopeOutcome::Unknown(_) + )); + } else { + sqlx::raw_sql("CREATE TRIGGER rewrap_fault BEFORE INSERT ON stock_rewraps BEGIN SELECT RAISE(ABORT, 'rewrap_fault'); END").execute(&mut fault).await.unwrap(); + assert!(matches!( + r.store.capture_stock_rewrap(request, proof(&r), &new).await, + Err(OperationError::StorageFailure) + )); + } + r.clock.0.store(0, Ordering::SeqCst); + sqlx::raw_sql("DROP TRIGGER rewrap_fault") + .execute(&mut fault) + .await + .unwrap(); + if uncertain { + sqlx::raw_sql("DROP TABLE rewrap_deferred_fault") + .execute(&mut fault) + .await + .unwrap(); + } + // Capture retries use only the retained original credential and bytes. + let request = StockRewrapRequest::new( + StockEnvelopeRequest::new( + r.binding.clone(), + first.checkpoint(), + original.attempt().operation_id(), + original.attempt().command_digest(), + new.recipient(), + None, + ) + .unwrap() + .with_envelope(new.event_id()), + new.id, + ); + let saved = committed_envelope( + r.store + .reconcile_stock_rewrap(request, proof(&r), &new) + .await + .unwrap(), + ); + assert_eq!(saved.event_id(), new.event_id()); + assert_eq!(saved.evidence(), first.evidence()); + r.clock.0.store(150, Ordering::SeqCst); + let loaded = r + .store + .stock_envelope(selected(&r, &original, &new).await, proof(&r)) + .await + .unwrap() + .unwrap(); + loaded.with_json(|raw| assert_eq!(raw, new.raw_json())); + assert_eq!(loaded.receipt(), saved); + assert_eq!( + committed_envelope(capture(&r, &original, &outer, None).await.unwrap()), + first + ); + balances(&r, 80, 9, 0, 1, 3).await; + balances(&r, 81, 8, 0, 2, 3).await; + fault.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn rewrapping_same_request_has_one_confirmed_admission_and_unknown_wrap_is_not_reissued() { + let (mut r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let id = OperationId::from_bytes([29; 32]); + let minimum = inventory_minimum(&r).await; + let request = || { + StockRewrapRequest::new( + StockEnvelopeRequest::new( + r.binding.clone(), + minimum, + original.attempt().operation_id(), + original.attempt().command_digest(), + first.recipient(), + None, + ) + .unwrap(), + id, + ) + }; + let (one, two) = futures::join!( + r.store.prepare_stock_rewrap(request(), proof(&r)), + r.store.prepare_stock_rewrap(request(), proof(&r)) + ); + let (StockRewrapOutcome::Claimed(one), StockRewrapOutcome::Retained(two)) = + (one.unwrap(), two.unwrap()) + else { + panic!("only first confirmed admission may qualify wrapping") + }; + assert_eq!(one, two); + let state = r + .store + .stock_rewrap_attempt(request(), proof(&r)) + .await + .unwrap() + .unwrap(); + assert_eq!(state.admission(), *one); + assert!(state.envelope().is_none()); + let checkpoint = inventory_minimum(&r).await; + reopen_plain(&mut r).await; + let request = StockRewrapRequest::new( + envelope_request(&r, &original, first.recipient(), None).await, + id, + ); + let StockRewrapOutcome::Retained(retained) = r + .store + .prepare_stock_rewrap(request, proof(&r)) + .await + .unwrap() + else { + panic!("reopened unknown wrapping outcome must not be reissued") + }; + assert_eq!(*retained, *one); + assert_eq!(inventory_minimum(&r).await, checkpoint); + let page = r + .store + .stock_rewraps( + envelope_request(&r, &original, first.recipient(), None).await, + None, + proof(&r), + ) + .await + .unwrap(); + assert_eq!(page.entries(), &[state]); + assert!(page.next_after().is_none()); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn rewrapping_dropped_admission_waiter_cannot_reclaim_the_same_request() { + let (mut r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let provider = reopen(&mut r).await; + let id = OperationId::from_bytes([30; 32]); + let request = StockRewrapRequest::new( + envelope_request(&r, &original, first.recipient(), None).await, + id, + ); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); + let mut pending = Box::pin(r.store.prepare_stock_rewrap(request, proof(&r))); + assert!(futures::poll!(pending.as_mut()).is_pending()); + provider.gate.entered(); + drop(pending); + provider.gate.release(); + let request = StockRewrapRequest::new( + envelope_request(&r, &original, first.recipient(), None).await, + id, + ); + let StockRewrapOutcome::Retained(retained) = r + .store + .prepare_stock_rewrap(request, proof(&r)) + .await + .unwrap() + else { + panic!("lost waiter must not regain an invocation") + }; + let state = r + .store + .stock_rewrap_attempt( + StockRewrapRequest::new( + envelope_request(&r, &original, first.recipient(), None).await, + id, + ), + proof(&r), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(*retained, state.admission()); + assert!(state.envelope().is_none()); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn rewrapping_admission_statement_and_commit_failures_repair_without_clock_or_new_permit() { + use sqlx::Connection; + for uncertain in [false, true] { + let (r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let mut db = database(&r).await; + let id = OperationId::from_bytes([31; 32]); + let minimum = inventory_minimum(&r).await; + let request = || { + StockRewrapRequest::new( + StockEnvelopeRequest::new( + r.binding.clone(), + minimum, + original.attempt().operation_id(), + original.attempt().command_digest(), + first.recipient(), + None, + ) + .unwrap(), + id, + ) + }; + if uncertain { + sqlx::raw_sql("CREATE TABLE admission_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER admission_fault AFTER INSERT ON stock_rewrap_admissions BEGIN INSERT INTO admission_deferred_fault VALUES(2); END").execute(&mut db).await.unwrap(); + assert!(matches!( + r.store + .prepare_stock_rewrap(request(), proof(&r)) + .await + .unwrap(), + StockRewrapOutcome::Unknown(_) + )); + } else { + sqlx::raw_sql("CREATE TRIGGER admission_fault BEFORE INSERT ON stock_rewrap_admissions BEGIN SELECT RAISE(ABORT, 'admission_fault'); END").execute(&mut db).await.unwrap(); + assert!(matches!( + r.store.prepare_stock_rewrap(request(), proof(&r)).await, + Err(OperationError::StorageFailure) + )); + } + r.clock.0.store(0, Ordering::SeqCst); + sqlx::raw_sql("DROP TRIGGER admission_fault") + .execute(&mut db) + .await + .unwrap(); + if uncertain { + sqlx::raw_sql("DROP TABLE admission_deferred_fault") + .execute(&mut db) + .await + .unwrap(); + } + r.store + .reconcile_stock_rewrap_admission(request(), proof(&r)) + .await + .unwrap(); + assert!( + r.store + .stock_rewrap_attempt(request(), proof(&r)) + .await + .is_err() + ); + r.clock.0.store(150, Ordering::SeqCst); + assert!( + r.store + .stock_rewrap_attempt(request(), proof(&r)) + .await + .unwrap() + .is_none() + ); + assert_eq!( + committed_envelope(capture(&r, &original, &outer, None).await.unwrap()), + first + ); + balances(&r, 80, 9, 0, 1, 3).await; + db.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn rewrapping_pages_include_uncaptured_admissions_at_sixteen_with_stable_cursors() { + let (mut r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let mut expected = Vec::new(); + for index in 0..17 { + let request = StockRewrapRequest::new( + envelope_request(&r, &original, first.recipient(), None).await, + OperationId::from_bytes([index; 32]), + ); + let StockRewrapOutcome::Claimed(admitted) = r + .store + .prepare_stock_rewrap(request, proof(&r)) + .await + .unwrap() + else { + panic!("distinct request requires a confirmed admission") + }; + expected.push(StockRewrapState::from_store_report(*admitted, None).unwrap()); + } + let checkpoint = inventory_minimum(&r).await; + reopen_plain(&mut r).await; + let page = r + .store + .stock_rewraps( + envelope_request(&r, &original, first.recipient(), None).await, + None, + proof(&r), + ) + .await + .unwrap(); + assert_eq!(page.entries(), &expected[..16]); + assert_eq!( + page.next_after(), + Some(expected[15].admission().checkpoint().revision()) + ); + assert_eq!(page.checkpoint(), checkpoint); + let last = r + .store + .stock_rewraps( + envelope_request(&r, &original, first.recipient(), None).await, + page.next_after(), + proof(&r), + ) + .await + .unwrap(); + assert_eq!(last.entries(), &expected[16..]); + assert!(last.next_after().is_none()); + let empty = r + .store + .stock_rewraps( + envelope_request(&r, &original, first.recipient(), None).await, + Some(expected[16].admission().checkpoint().revision()), + proof(&r), + ) + .await + .unwrap(); + assert!(empty.entries().is_empty()); + assert!(empty.next_after().is_none()); + assert_eq!(inventory_minimum(&r).await, checkpoint); + assert_eq!( + committed_envelope(capture(&r, &original, &outer, None).await.unwrap()), + first + ); + balances(&r, 80, 9, 0, 1, 3).await; + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn rewrapping_oversized_unprotected_index_is_refused_without_changing_originals() { + use sqlx::Connection; + let (r, original, _, outer) = setup(18).await; + let first = committed_envelope(capture(&r, &original, &outer, None).await.unwrap()); + let new = additional(&r, &original, first).await; + let before = inventory_minimum(&r).await; + let mut db = database(&r).await; + sqlx::raw_sql("PRAGMA foreign_keys=OFF; PRAGMA ignore_check_constraints=ON") + .execute(&mut db) + .await + .unwrap(); + let phantom = OperationId::from_bytes([199; 32]); + sqlx::query("INSERT INTO stock_rewrap_admissions(actor,operation_id,recipient,request_id,entry_id) SELECT actor,operation_id,recipient,?,zeroblob(1048576) FROM stock_envelopes LIMIT 1") + .bind(phantom.as_bytes().as_slice()).execute(&mut db).await.unwrap(); + assert!(matches!( + r.store + .stock_rewraps( + envelope_request(&r, &original, first.recipient(), None).await, + None, + proof(&r) + ) + .await, + Err(OperationError::RecoveryRequired) + )); + assert!(matches!( + r.store + .stock_rewrap_attempt( + StockRewrapRequest::new( + envelope_request(&r, &original, first.recipient(), None).await, + phantom + ), + proof(&r) + ) + .await, + Err(OperationError::RecoveryRequired) + )); + assert!(matches!( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await, + Err(OperationError::RecoveryRequired) + )); + assert_eq!(inventory_minimum(&r).await, before); + sqlx::query("DELETE FROM stock_rewrap_admissions WHERE request_id=?") + .bind(phantom.as_bytes().as_slice()) + .execute(&mut db) + .await + .unwrap(); + sqlx::raw_sql("PRAGMA ignore_check_constraints=OFF; PRAGMA foreign_keys=ON") + .execute(&mut db) + .await + .unwrap(); + let saved = committed_envelope( + r.store + .capture_stock_rewrap(capture_request(&r, &original, &new).await, proof(&r), &new) + .await + .unwrap(), + ); + assert_eq!( + saved.rewrap_admission_transaction_id(), + Some(new.admission.unwrap().transaction_id()) + ); + let loaded = r + .store + .stock_envelope( + envelope_request(&r, &original, first.recipient(), None).await, + proof(&r), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(loaded.receipt(), first); + loaded.with_json(|raw| assert_eq!(raw, outer.raw_json())); + balances(&r, 80, 9, 0, 1, 3).await; + db.close().await.unwrap(); + r.store.close().await.unwrap(); +} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/signing_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/signing_tests.rs @@ -352,9 +352,7 @@ async fn dropped_t1_observer_keeps_owned_work_and_close_drains_before_original_r ) .unwrap(); let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .bind_stock_signing_intents(request, r.enrollment.proof()), @@ -406,9 +404,7 @@ async fn t1_final_permission_order_root_and_clock_witnesses_refuse_changes_after .unwrap(); let provider = reopen(&mut r).await; let mut raw = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin( r.store .bind_stock_signing_intents(request, r.enrollment.proof()), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/test_provider.rs b/crates/storage_sqlite/src/workspace/stock/public_source/test_provider.rs @@ -155,9 +155,7 @@ async fn public_source_close_drains_admitted_work_after_observer_loss() { let provider = reopen(&mut r).await; let capture = r.capture("listing_fixed"); let minimum = r.minimum().await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut future = Box::pin(r.store.retain_stock_listing( r.binding.clone(), minimum, @@ -211,9 +209,7 @@ async fn public_source_writes_recheck_expiry_and_head_rows_after_actual_protecti let capture = r.capture("listing_unsupported"); let minimum = r.minimum().await; let mut raw = database(&r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut future = Box::pin(r.store.retain_stock_listing( r.binding.clone(), minimum, diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/tests.rs @@ -34,6 +34,7 @@ fn vector(name: &str) -> String { .into() } struct Rig { + catalog: i64, fixture: CryptoFixture, path: std::path::PathBuf, store: NativeWorkspace, @@ -87,6 +88,7 @@ impl Rig { .await .unwrap(); Self { + catalog, fixture, path, store, @@ -95,6 +97,9 @@ impl Rig { clock, } } + fn authority_schema(&self) -> &'static str { + crate::workspace::stock::tests::catalog_authority_schema(self.catalog) + } fn capture_raw(&self, raw: &str) -> StockListingCapture { let mut observed = ObservedHead::listing( self.enrollment.input().participant(), diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/transaction.rs b/crates/storage_sqlite/src/workspace/stock/public_source/transaction.rs @@ -31,7 +31,7 @@ async fn access( } let (authority, record, root, grant) = super::super::read(turn.connection, binding.input(), turn.crypto).await?; - if !matches!(authority.catalog, 8..=17) || authority.public_sources.is_none() { + if !matches!(authority.catalog, 8..=18) || authority.public_sources.is_none() { return Err(OperationError::UnsupportedOperation); } let current = record.authenticate(binding.input(), proof, turn.clock.now()?)?; diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/unissued_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/unissued_tests.rs @@ -362,9 +362,7 @@ async fn lost_original_negative_append_waiter_drains_and_reopens_the_same_fact() let original = value.attempt().attempt_id(); let reason = value.reason(); let provider = reopen(&mut r).await; - provider - .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v17", 0); + provider.gate.arm(Direction::Wrap, r.authority_schema(), 0); let mut pending = Box::pin(capture(&r, &value)); assert!(futures::poll!(pending.as_mut()).is_pending()); provider.gate.entered(); diff --git a/crates/storage_sqlite/src/workspace/stock/schema.rs b/crates/storage_sqlite/src/workspace/stock/schema.rs @@ -1,7 +1,7 @@ //! Exact stock catalogs. Enrollment-only version1 is retained without upgrade. use super::WorkspaceError; use sqlx::SqliteConnection; -pub(super) const CURRENT: i64 = 17; +pub(super) const CURRENT: i64 = 18; const AUTHORITY: &str = "CREATE TABLE stock_authority (singleton INTEGER PRIMARY KEY CHECK(singleton=1), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT"; const GRANTS: &str = "CREATE TABLE stock_grants (grant_id BLOB PRIMARY KEY CHECK(length(grant_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"; const POOLS: &str = "CREATE TABLE stock_pools (pool_id BLOB PRIMARY KEY CHECK(length(pool_id)=32), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"; @@ -21,6 +21,7 @@ const OPERATIONS_V14: &str = "CREATE TABLE stock_operations (actor BLOB NOT NULL const OPERATIONS_V15: &str = "CREATE TABLE stock_operations (actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL REFERENCES stock_grants(grant_id), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), command_digest BLOB NOT NULL CHECK(length(command_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), pool_id BLOB REFERENCES stock_pools(pool_id) DEFERRABLE INITIALLY DEFERRED, revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), family INTEGER NOT NULL DEFAULT 0 CHECK(family BETWEEN 0 AND 9), order_id BLOB CHECK(order_id IS NULL OR length(order_id)=32), related_operation BLOB CHECK(related_operation IS NULL OR length(related_operation)=32), subject_grant BLOB REFERENCES stock_grants(grant_id) CHECK(subject_grant IS NULL OR length(subject_grant)=32), PRIMARY KEY(actor,grant_id,operation_id), CHECK((family=0 AND pool_id IS NOT NULL AND order_id IS NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family=1 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NOT NULL) OR (family=2 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family BETWEEN 3 AND 9 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NULL))) STRICT, WITHOUT ROWID"; const OPERATIONS_V16: &str = "CREATE TABLE stock_operations (actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL REFERENCES stock_grants(grant_id), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), command_digest BLOB NOT NULL CHECK(length(command_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), pool_id BLOB REFERENCES stock_pools(pool_id) DEFERRABLE INITIALLY DEFERRED, revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), family INTEGER NOT NULL DEFAULT 0 CHECK(family BETWEEN 0 AND 10), order_id BLOB CHECK(order_id IS NULL OR length(order_id)=32), related_operation BLOB CHECK(related_operation IS NULL OR length(related_operation)=32), subject_grant BLOB REFERENCES stock_grants(grant_id) CHECK(subject_grant IS NULL OR length(subject_grant)=32), PRIMARY KEY(actor,grant_id,operation_id), CHECK((family=0 AND pool_id IS NOT NULL AND order_id IS NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family=1 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NOT NULL) OR (family=2 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family BETWEEN 3 AND 10 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NULL))) STRICT, WITHOUT ROWID"; const OPERATIONS_V17: &str = "CREATE TABLE stock_operations (actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL REFERENCES stock_grants(grant_id), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), command_digest BLOB NOT NULL CHECK(length(command_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), pool_id BLOB REFERENCES stock_pools(pool_id) DEFERRABLE INITIALLY DEFERRED, revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), family INTEGER NOT NULL DEFAULT 0 CHECK(family BETWEEN 0 AND 12), order_id BLOB CHECK(order_id IS NULL OR length(order_id)=32), related_operation BLOB CHECK(related_operation IS NULL OR length(related_operation)=32), subject_grant BLOB REFERENCES stock_grants(grant_id) CHECK(subject_grant IS NULL OR length(subject_grant)=32), PRIMARY KEY(actor,grant_id,operation_id), CHECK((family=0 AND pool_id IS NOT NULL AND order_id IS NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family=1 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NOT NULL) OR (family=2 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family BETWEEN 3 AND 12 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NULL))) STRICT, WITHOUT ROWID"; +const OPERATIONS_V18: &str = "CREATE TABLE stock_operations (actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL REFERENCES stock_grants(grant_id), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), command_digest BLOB NOT NULL CHECK(length(command_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), pool_id BLOB REFERENCES stock_pools(pool_id) DEFERRABLE INITIALLY DEFERRED, revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), family INTEGER NOT NULL DEFAULT 0 CHECK(family BETWEEN 0 AND 14), order_id BLOB CHECK(order_id IS NULL OR length(order_id)=32), related_operation BLOB CHECK(related_operation IS NULL OR length(related_operation)=32), subject_grant BLOB REFERENCES stock_grants(grant_id) CHECK(subject_grant IS NULL OR length(subject_grant)=32), PRIMARY KEY(actor,grant_id,operation_id), CHECK((family=0 AND pool_id IS NOT NULL AND order_id IS NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family=1 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NOT NULL) OR (family=2 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NULL AND subject_grant IS NULL) OR (family BETWEEN 3 AND 14 AND pool_id IS NULL AND order_id IS NOT NULL AND related_operation IS NOT NULL AND subject_grant IS NULL))) STRICT, WITHOUT ROWID"; const MOVEMENTS: &str = "CREATE TABLE stock_movements (movement_id BLOB PRIMARY KEY CHECK(length(movement_id)=32), actor BLOB NOT NULL CHECK(length(actor)=32), grant_id BLOB NOT NULL CHECK(length(grant_id)=32), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), pool_id BLOB NOT NULL REFERENCES stock_pools(pool_id), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), FOREIGN KEY(actor,grant_id,operation_id) REFERENCES stock_operations(actor,grant_id,operation_id)) STRICT, WITHOUT ROWID"; pub(super) fn objects( version: i64, @@ -31,13 +32,15 @@ pub(super) fn objects( ]; match version { 1 => {} - 2..=17 => objects.extend([ + 2..=18 => objects.extend([ ("table", "stock_pools", "stock_pools", POOLS), ( "table", "stock_operations", "stock_operations", - if version >= 17 { + if version >= 18 { + OPERATIONS_V18 + } else if version >= 17 { OPERATIONS_V17 } else if version >= 16 { OPERATIONS_V16 @@ -94,7 +97,7 @@ pub(super) fn objects( if version >= 5 { objects.push(("table","stock_mappings","stock_mappings","CREATE TABLE stock_mappings (listing_author BLOB NOT NULL CHECK(length(listing_author)=32), listing_d BLOB NOT NULL CHECK(length(listing_d)=16), option_id BLOB NOT NULL CHECK(length(option_id)=32), pool_id BLOB NOT NULL REFERENCES stock_pools(pool_id), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(listing_author,listing_d,option_id)) STRICT, WITHOUT ROWID")); } - if (6..=17).contains(&version) { + if (6..=18).contains(&version) { objects.push(("table","stock_source_records","stock_source_records","CREATE TABLE stock_source_records (record_id BLOB PRIMARY KEY CHECK(length(record_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); objects.push(("table","stock_source_evidence","stock_source_evidence","CREATE TABLE stock_source_evidence (envelope_id BLOB PRIMARY KEY CHECK(length(envelope_id)=32), record_id BLOB REFERENCES stock_source_records(record_id), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); objects.push(("index","stock_source_transaction_identity","stock_source_evidence","CREATE UNIQUE INDEX stock_source_transaction_identity ON stock_source_evidence(transaction_id)")); @@ -130,7 +133,7 @@ pub(super) fn objects( objects.push(("table","stock_orders","stock_orders","CREATE TABLE stock_orders (order_id BLOB PRIMARY KEY CHECK(length(order_id)=32), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); } } - if matches!(version, 8..=17) { + if matches!(version, 8..=18) { objects.push(("table","stock_public_events","stock_public_events","CREATE TABLE stock_public_events (event_id BLOB PRIMARY KEY CHECK(length(event_id)=32), listing_author BLOB NOT NULL CHECK(length(listing_author)=32), listing_d BLOB NOT NULL CHECK(length(listing_d)=16), created_at BLOB NOT NULL CHECK(length(created_at)=8), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); objects.push(("index","stock_public_transaction_identity","stock_public_events","CREATE UNIQUE INDEX stock_public_transaction_identity ON stock_public_events(transaction_id)")); objects.push(( @@ -208,6 +211,18 @@ pub(super) fn objects( objects.push(("table","stock_delivery_observations","stock_delivery_observations","CREATE TABLE stock_delivery_observations (actor BLOB NOT NULL CHECK(length(actor)=32), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), recipient BLOB NOT NULL CHECK(length(recipient)=32), request_key BLOB NOT NULL CHECK(length(request_key)=32), target_key BLOB NOT NULL CHECK(length(target_key)=32), kind INTEGER NOT NULL CHECK(kind BETWEEN 1 AND 6), entry_id BLOB NOT NULL CHECK(length(entry_id)=32), PRIMARY KEY(actor,operation_id,recipient,request_key,target_key,kind), FOREIGN KEY(actor,operation_id,recipient,request_key) REFERENCES stock_delivery_attempts(actor,operation_id,recipient,request_key), FOREIGN KEY(actor,entry_id) REFERENCES stock_operations(actor,operation_id)) STRICT, WITHOUT ROWID")); objects.push(("index","stock_delivery_observation_entry","stock_delivery_observations","CREATE UNIQUE INDEX stock_delivery_observation_entry ON stock_delivery_observations(actor,entry_id)")); } + if version >= 18 { + objects.push(("table","stock_rewrap_admissions","stock_rewrap_admissions","CREATE TABLE stock_rewrap_admissions (actor BLOB NOT NULL CHECK(length(actor)=32), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), recipient BLOB NOT NULL CHECK(length(recipient)=32), request_id BLOB NOT NULL CHECK(length(request_id)=32), entry_id BLOB NOT NULL CHECK(length(entry_id)=32), PRIMARY KEY(actor,operation_id,recipient,request_id), FOREIGN KEY(actor,operation_id,recipient) REFERENCES stock_envelopes(actor,operation_id,recipient), FOREIGN KEY(actor,entry_id) REFERENCES stock_operations(actor,operation_id)) STRICT, WITHOUT ROWID")); + objects.push(("index","stock_rewrap_admission_entry","stock_rewrap_admissions","CREATE UNIQUE INDEX stock_rewrap_admission_entry ON stock_rewrap_admissions(actor,entry_id)")); + objects.push(("table","stock_rewraps","stock_rewraps","CREATE TABLE stock_rewraps (actor BLOB NOT NULL CHECK(length(actor)=32), operation_id BLOB NOT NULL CHECK(length(operation_id)=32), recipient BLOB NOT NULL CHECK(length(recipient)=32), admission_entry BLOB NOT NULL CHECK(length(admission_entry)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), entry_id BLOB NOT NULL CHECK(length(entry_id)=32), PRIMARY KEY(actor,operation_id,recipient,event_id), FOREIGN KEY(actor,operation_id,recipient) REFERENCES stock_envelopes(actor,operation_id,recipient), FOREIGN KEY(actor,admission_entry) REFERENCES stock_rewrap_admissions(actor,entry_id), FOREIGN KEY(actor,entry_id) REFERENCES stock_operations(actor,operation_id)) STRICT, WITHOUT ROWID")); + objects.push(("index","stock_rewrap_capture_admission","stock_rewraps","CREATE UNIQUE INDEX stock_rewrap_capture_admission ON stock_rewraps(actor,admission_entry)")); + objects.push(( + "index", + "stock_rewrap_entry", + "stock_rewraps", + "CREATE UNIQUE INDEX stock_rewrap_entry ON stock_rewraps(actor,entry_id)", + )); + } Ok(objects) } pub(super) async fn admit(connection: &mut SqliteConnection) -> Result<i64, WorkspaceError> { diff --git a/crates/storage_sqlite/src/workspace/stock/signing_plan.rs b/crates/storage_sqlite/src/workspace/stock/signing_plan.rs @@ -148,7 +148,7 @@ pub(in crate::workspace::stock) async fn load( proof: &AttachmentProof, ) -> Result<Authorized, OperationError> { let access = Box::pin(turn.access(binding, minimum, proof)).await?; - if !matches!(access.authority.catalog, 10..=17) { + if !matches!(access.authority.catalog, 10..=18) { return Err(OperationError::UnsupportedOperation); } let original = Box::pin(acceptance::codec::read( diff --git a/crates/storage_sqlite/src/workspace/stock/snapshot.rs b/crates/storage_sqlite/src/workspace/stock/snapshot.rs @@ -338,7 +338,7 @@ async fn read_authorized( .authority .inventory .ok_or(OperationError::RecoveryRequired)?; - let delivery = if auth.access.authority.catalog == 17 { + let delivery = if matches!(auth.access.authority.catalog, 17 | 18) { Some(Box::new( Box::pin(super::delivery::snapshot( turn, diff --git a/crates/storage_sqlite/src/workspace/stock/source/transaction.rs b/crates/storage_sqlite/src/workspace/stock/source/transaction.rs @@ -28,7 +28,7 @@ async fn access( } let (authority, record, root, grant) = super::super::read(turn.connection, binding.input(), turn.crypto).await?; - if !(6..=17).contains(&authority.catalog) { + if !(6..=18).contains(&authority.catalog) { return Err(OperationError::UnsupportedOperation); } let current = record.authenticate(binding.input(), proof, turn.clock.now()?)?; @@ -114,7 +114,7 @@ pub(in crate::workspace) async fn history( proof: AttachmentProof, ) -> Result<StockHistorySnapshot, OperationError> { let access = access(turn, &binding, minimum, &proof).await?; - if !matches!(access.authority.catalog, 8..=17) { + if !matches!(access.authority.catalog, 8..=18) { return Err(OperationError::UnsupportedOperation); } let prepared = Box::pin(super::history::prepare( @@ -175,7 +175,7 @@ pub(in crate::workspace) async fn inspect_request( proof: AttachmentProof, ) -> Result<StockRequestSnapshot, OperationError> { let access = access(turn, &binding, minimum, &proof).await?; - if !matches!(access.authority.catalog, 8..=17) { + if !matches!(access.authority.catalog, 8..=18) { return Err(OperationError::UnsupportedOperation); } let prepared = Box::pin(super::request::prepare( diff --git a/crates/storage_sqlite/src/workspace/stock/tests.rs b/crates/storage_sqlite/src/workspace/stock/tests.rs @@ -1,4 +1,27 @@ use super::*; +pub(in crate::workspace::stock) fn catalog_authority_schema(catalog: i64) -> &'static str { + match catalog { + 1 => "radroots.seller_stock.authority.v1", + 2 => "radroots.seller_stock.authority.v2", + 3 => "radroots.seller_stock.authority.v3", + 4 => "radroots.seller_stock.authority.v4", + 5 => "radroots.seller_stock.authority.v5", + 6 => "radroots.seller_stock.authority.v6", + 7 => "radroots.seller_stock.authority.v7", + 8 => "radroots.seller_stock.authority.v8", + 9 => "radroots.seller_stock.authority.v9", + 10 => "radroots.seller_stock.authority.v10", + 11 => "radroots.seller_stock.authority.v11", + 12 => "radroots.seller_stock.authority.v12", + 13 => "radroots.seller_stock.authority.v13", + 14 => "radroots.seller_stock.authority.v14", + 15 => "radroots.seller_stock.authority.v15", + 16 => "radroots.seller_stock.authority.v16", + 17 => "radroots.seller_stock.authority.v17", + 18 => "radroots.seller_stock.authority.v18", + _ => panic!("unsupported private stock fixture catalog"), + } +} use crate::workspace::{ fs::Kind, tests::{CryptoFixture, participant}, @@ -109,7 +132,7 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang ) .await .unwrap(); - assert_eq!(schema::admit(&mut connection).await, Ok(17)); + assert_eq!(schema::admit(&mut connection).await, Ok(schema::CURRENT)); assert_eq!(schema::integrity(&mut connection).await, Ok(())); let root: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_authority") .fetch_one(&mut connection) @@ -117,18 +140,18 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang .unwrap(); let clear = fixture .crypto() - .open_stock_root(enrollment.input(), 17, &root) + .open_stock_root(enrollment.input(), schema::CURRENT, &root) .await .unwrap(); let authority = clear - .expose_secret(|bytes| Authority::decode(bytes, 17)) + .expose_secret(|bytes| Authority::decode(bytes, schema::CURRENT)) .unwrap(); clear.expose_secret(|bytes| { let original:serde_json::Value=serde_json::from_slice(bytes).unwrap(); assert_eq!(original["inventory"]["mappings"],"0"); for bad in [serde_json::json!([]),serde_json::json!({"revision":"1","pools":"1","movements":"1","head":original["inventory"]["head"]})] { let mut value=original.clone();value["inventory"]=bad; - assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),17).is_err()); + assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),schema::CURRENT).is_err()); } for bad in [ serde_json::json!([]), @@ -139,7 +162,7 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang serde_json::json!({"revision":"1","records":"2","parts":"3","head":"01".repeat(32)}), ] { let mut value=original.clone();value["sources"]=bad; - assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),17).is_err()); + assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),schema::CURRENT).is_err()); } }); assert_eq!(authority.input, *enrollment.input()); @@ -189,7 +212,7 @@ async fn current_and_retained_roots_bind_the_complete_namespace_with_distinct_ca let caller = namespace.attachment(GrantId::from_bytes([9; 32])).unwrap(); let crypto = fixture.crypto(); let clear = b"synthetic context payload"; - for version in 4..=17 { + for version in 4..=schema::CURRENT { let current = crypto .seal_stock_root(&owner, version, clear) .await @@ -277,7 +300,7 @@ async fn retained_v10_preserves_prior_families_and_signing_plan_retention() { } #[tokio::test] async fn retained_v11_preserves_prior_families_and_adds_claims_and_obtained_evidence() { - assert_eq!(schema::CURRENT, 17); + assert_eq!(schema::CURRENT, 18); retained_inventory_catalog(11).await; } // Exact catalog fixtures exercise retained/successor codecs; they are not @@ -322,7 +345,7 @@ pub(in crate::workspace::stock) async fn literal_enrollment_catalog( catalog: i64, enrollment: &StockEnrollment, ) { - assert!(matches!(catalog, 13..=16)); + assert!(matches!(catalog, 13..=17)); let record = enrollment.record.lock().unwrap().take().unwrap(); literal_catalog_contents( fixture, @@ -381,7 +404,7 @@ async fn literal_catalog_contents( if catalog >= 7 { value["inventory"]["orders"] = serde_json::json!("0"); } - if matches!(catalog, 8..=16) { + if matches!(catalog, 8..=17) { value["public_sources"] = serde_json::json!({"revision":"0","events":"0","heads":"0","parts":"0","head":null}); } @@ -430,6 +453,7 @@ async fn literal_catalog_contents( 14 => "PRAGMA user_version=14", 15 => "PRAGMA user_version=15", 16 => "PRAGMA user_version=16", + 17 => "PRAGMA user_version=17", _ => unreachable!(), }) .execute(&mut *tx) @@ -454,7 +478,7 @@ async fn retained_inventory_catalog(catalog: i64) { assert_eq!(authority.source_checkpoint().is_some(), catalog >= 6); assert_eq!( authority.listing_checkpoint().is_some(), - matches!(catalog, 8..=16) + matches!(catalog, 8..=17) ); let minimum = authority.inventory_checkpoint().unwrap(); let context = CommandContextData::new( @@ -697,7 +721,7 @@ async fn retained_inventory_catalog(catalog: i64) { .fetch_one(&mut connection) .await .unwrap(); - let old = if matches!(catalog, 7..=16) { + let old = if matches!(catalog, 7..=17) { let retained = ledger::read( &mut connection, &input, @@ -750,7 +774,7 @@ async fn retained_inventory_catalog(catalog: i64) { // inside a real SQL transaction. Row counts and the protected header // stay unchanged while one referenced ciphertext changes. for part in [false, true] { - if part && !matches!(catalog, 7..=16) { + if part && !matches!(catalog, 7..=17) { continue; } let (authority, _, _, _) = read(&mut connection, &input, &fixture.crypto()) @@ -829,6 +853,7 @@ async fn retained_inventory_catalog(catalog: i64) { 14 => "PRAGMA user_version=13", 15 => "PRAGMA user_version=14", 16 => "PRAGMA user_version=15", + 17 => "PRAGMA user_version=16", _ => unreachable!(), }) .execute(&mut connection) @@ -958,30 +983,36 @@ async fn retained_enrollment_v1_authenticates_but_never_auto_creates_inventory() #[tokio::test] async fn retained_v12_preserves_initial_installation_catalog_without_upgrade() { - assert_eq!(schema::CURRENT, 17); + assert_eq!(schema::CURRENT, 18); retained_inventory_catalog(12).await; } #[tokio::test] async fn retained_v13_authenticates_literal_catalog_and_original_inventory_records() { - assert_eq!(schema::CURRENT, 17); + assert_eq!(schema::CURRENT, 18); retained_inventory_catalog(13).await; } #[tokio::test] async fn retained_v14_authenticates_literal_catalog_and_original_inventory_records() { - assert_eq!(schema::CURRENT, 17); + assert_eq!(schema::CURRENT, 18); retained_inventory_catalog(14).await; } #[tokio::test] async fn retained_v15_authenticates_literal_catalog_and_original_inventory_records() { - assert_eq!(schema::CURRENT, 17); + assert_eq!(schema::CURRENT, 18); retained_inventory_catalog(15).await; } #[tokio::test] async fn retained_v16_authenticates_literal_catalog_and_original_inventory_records() { - assert_eq!(schema::CURRENT, 17); + assert_eq!(schema::CURRENT, 18); retained_inventory_catalog(16).await; } + +#[tokio::test] +async fn retained_v17_authenticates_original_delivery_catalog_without_upgrade() { + assert_eq!(schema::CURRENT, 18); + retained_inventory_catalog(17).await; +} diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -119,7 +119,7 @@ enum Job { Reply<radroots_storage::inventory::StockDeliveryObservationPage, OperationError>, ), RecoverStockEnvelope( - Box<radroots_storage::inventory::StockEnvelopeRequest>, + stock::envelope::CaptureRequest, AttachmentProof, Box<radroots_storage::command::PrivateEnvelopeCandidate>, Reply<radroots_storage::inventory::StockEnvelopeOutcome, OperationError>, @@ -131,7 +131,7 @@ enum Job { Reply<radroots_storage::inventory::StockDeliveryObservationOutcome, OperationError>, ), CaptureStockEnvelope( - Box<radroots_storage::inventory::StockEnvelopeRequest>, + stock::envelope::CaptureRequest, AttachmentProof, Box<radroots_storage::command::PrivateEnvelopeCandidate>, Reply<radroots_storage::inventory::StockEnvelopeOutcome, OperationError>, @@ -141,6 +141,27 @@ enum Job { AttachmentProof, Reply<Option<radroots_storage::inventory::StockEnvelopeSource>, OperationError>, ), + PrepareStockRewrap( + Box<radroots_storage::inventory::StockRewrapRequest>, + AttachmentProof, + Reply<radroots_storage::inventory::StockRewrapOutcome, OperationError>, + ), + StockRewrapAttempt( + Box<radroots_storage::inventory::StockRewrapRequest>, + AttachmentProof, + Reply<Option<radroots_storage::inventory::StockRewrapState>, OperationError>, + ), + RecoverStockRewrapAdmission( + Box<radroots_storage::inventory::StockRewrapRequest>, + AttachmentProof, + Reply<(), OperationError>, + ), + StockRewraps( + Box<radroots_storage::inventory::StockEnvelopeRequest>, + Option<radroots_domain::Sequence>, + AttachmentProof, + Reply<radroots_storage::inventory::StockRewrapPage, OperationError>, + ), CaptureStockEvidence( Box<radroots_storage::inventory::StockEvidenceRequest>, AttachmentProof, @@ -437,6 +458,18 @@ impl Job { Self::StockEnvelope(_, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } + Self::PrepareStockRewrap(_, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::StockRewrapAttempt(_, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::RecoverStockRewrapAdmission(_, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::StockRewraps(_, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } Self::StockEvidence(_, _, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } @@ -721,6 +754,10 @@ impl Handle { | Job::RecoverStockObservation(..) | Job::CaptureStockEnvelope(..) | Job::StockEnvelope(..) + | Job::PrepareStockRewrap(..) + | Job::StockRewrapAttempt(..) + | Job::RecoverStockRewrapAdmission(..) + | Job::StockRewraps(..) | Job::CaptureStockEvidence(..) | Job::RecoverStockEvidence(..) | Job::StockEvidence(..) @@ -738,6 +775,24 @@ impl Handle { continue; } let job = match job { + Job::RecoverStockRewrapAdmission(request, proof, reply) => { + let result = Box::pin( + super::recovery::RecoveryTurn { + connection: &mut connection, + cached_grant: &mut cached_grant, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + options: &options, + } + .reconcile_rewrap_admission(*request, proof), + ) + .await; + let _ = reply.send(result); + continue; + } Job::RecoverStockEnvelope(request, proof, candidate, reply) => { let result = Box::pin( super::recovery::RecoveryTurn { @@ -750,7 +805,7 @@ impl Handle { uncertain: &mut uncertain, options: &options, } - .capture_envelope(*request, proof, *candidate), + .capture_envelope(request, proof, *candidate), ) .await; let _ = reply.send(result); @@ -1162,7 +1217,7 @@ impl Handle { let unknown = radroots_storage::inventory::StockEnvelopeOutcome::Unknown(request.attempt()); let (reply, result) = oneshot::channel(); self.send(Job::RecoverStockEnvelope( - Box::new(request), + stock::envelope::CaptureRequest::Original(Box::new(request)), proof, Box::new(candidate), reply, @@ -1259,7 +1314,7 @@ impl Handle { let unknown = radroots_storage::inventory::StockEnvelopeOutcome::Unknown(request.attempt()); let (reply, result) = oneshot::channel(); self.send(Job::CaptureStockEnvelope( - Box::new(request), + stock::envelope::CaptureRequest::Original(Box::new(request)), proof, Box::new(candidate), reply, @@ -1275,6 +1330,65 @@ impl Handle { self.send(Job::StockEnvelope(Box::new(request), proof, reply))?; result.await.map_err(|_| OperationError::RecoveryRequired)? } + pub(super) async fn prepare_stock_rewrap( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + ) -> Result<radroots_storage::inventory::StockRewrapOutcome, OperationError> { + let unknown = radroots_storage::inventory::StockRewrapOutcome::Unknown(request.attempt()); + let (reply, result) = oneshot::channel(); + self.send(Job::PrepareStockRewrap(Box::new(request), proof, reply))?; + result.await.unwrap_or(Ok(unknown)) + } + pub(super) async fn stock_rewrap_attempt( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + ) -> Result<Option<radroots_storage::inventory::StockRewrapState>, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::StockRewrapAttempt(Box::new(request), proof, reply))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } + pub(super) async fn reconcile_stock_rewrap_admission( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + ) -> Result<(), OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::RecoverStockRewrapAdmission( + Box::new(request), + proof, + reply, + ))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } + pub(super) async fn capture_stock_rewrap( + &self, + request: radroots_storage::inventory::StockRewrapRequest, + proof: AttachmentProof, + candidate: radroots_storage::command::PrivateEnvelopeCandidate, + reconcile: bool, + ) -> Result<radroots_storage::inventory::StockEnvelopeOutcome, OperationError> { + let unknown = radroots_storage::inventory::StockEnvelopeOutcome::Unknown(request.attempt()); + let (reply, result) = oneshot::channel(); + let request = stock::envelope::CaptureRequest::Rewrap(Box::new(request)); + self.send(if reconcile { + Job::RecoverStockEnvelope(request, proof, Box::new(candidate), reply) + } else { + Job::CaptureStockEnvelope(request, proof, Box::new(candidate), reply) + })?; + result.await.unwrap_or(Ok(unknown)) + } + pub(super) async fn stock_rewraps( + &self, + request: radroots_storage::inventory::StockEnvelopeRequest, + after: Option<radroots_domain::Sequence>, + proof: AttachmentProof, + ) -> Result<radroots_storage::inventory::StockRewrapPage, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::StockRewraps(Box::new(request), after, proof, reply))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } pub(super) async fn capture_stock_signing_evidence( &self, evidence: radroots_storage::inventory::StockEvidenceRequest, @@ -1469,6 +1583,10 @@ impl Handle { | Job::RecoverStockObservation(..) | Job::CaptureStockEnvelope(..) | Job::StockEnvelope(..) + | Job::PrepareStockRewrap(..) + | Job::StockRewrapAttempt(..) + | Job::RecoverStockRewrapAdmission(..) + | Job::StockRewraps(..) | Job::StockEvidence(..) | Job::StockUnissued(..) | Job::StockEvidencePage(..) diff --git a/crates/storage_sqlite/src/workspace/worker/dispatch.rs b/crates/storage_sqlite/src/workspace/worker/dispatch.rs @@ -453,7 +453,7 @@ pub(super) fn run<'a>( }), Job::CaptureStockEnvelope(request, proof, candidate, reply) => Box::pin(async move { let result = if kind == Kind::SellerStock { - Box::pin(stock::envelope::capture( + Box::pin(stock::envelope::capture_obtained( &mut stock::inventory::Turn { connection, namespace, @@ -462,7 +462,7 @@ pub(super) fn run<'a>( clock, uncertain, }, - *request, + request, proof, *candidate, )) @@ -492,6 +492,67 @@ pub(super) fn run<'a>( }; let _ = reply.send(result); }), + Job::StockRewrapAttempt(request, proof, reply) => Box::pin(async move { + let result = if kind == Kind::SellerStock { + Box::pin(stock::envelope::rewrap_attempt( + &mut stock::inventory::Turn { + connection, + namespace, + selected: input, + crypto, + clock, + uncertain, + }, + *request, + proof, + )) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + }), + Job::PrepareStockRewrap(request, proof, reply) => Box::pin(async move { + let result = if kind == Kind::SellerStock { + Box::pin(stock::envelope::prepare_rewrap( + &mut stock::inventory::Turn { + connection, + namespace, + selected: input, + crypto, + clock, + uncertain, + }, + *request, + proof, + )) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + }), + Job::StockRewraps(request, after, proof, reply) => Box::pin(async move { + let result = if kind == Kind::SellerStock { + Box::pin(stock::envelope::page( + &mut stock::inventory::Turn { + connection, + namespace, + selected: input, + crypto, + clock, + uncertain, + }, + *request, + after, + proof, + )) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + }), Job::CaptureStockEvidence(evidence, proof, reply) => Box::pin(async move { let result = if kind == Kind::SellerStock { Box::pin(stock::issuance::evidence::capture( @@ -793,7 +854,8 @@ pub(super) fn run<'a>( } let _ = reply.send(result); }), - job @ (Job::RecoverStockEnvelope(..) + job @ (Job::RecoverStockRewrapAdmission(..) + | Job::RecoverStockEnvelope(..) | Job::RecoverStockObservation(..) | Job::RecoverCapture(..) | Job::RecoverStockEvidence(..) diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -129,7 +129,52 @@ struct StockEnvelopeRetention { #[derive(Deserialize)] #[serde(deny_unknown_fields)] +struct StockRewrapping { + journal_family: u16, + admission_journal_family: u16, + admission_payload_bytes: u16, + admission_window_seconds_max: u16, + admission_port: String, + admission_recovery_port: String, + admission_query_port: String, + explicit_request_id_required: bool, + newly_confirmed_admission_before_wrapping: bool, + existing_or_uncertain_admission_grants_invocation: bool, + unknown_admissions_count_toward_limit: bool, + descriptor_includes_uncaptured_admissions: bool, + admission_repair_grants_history_or_invocation: bool, + + payload_version: u16, + payload_prefix_bytes: u32, + supported_catalogs: Vec<u16>, + retained_unsupported_catalogs: Vec<u16>, + raw_max_bytes: u32, + worker_charge_bytes: u32, + additional_envelopes_per_recipient_max: u16, + descriptor_page_max: u16, + capture_port: String, + recovery_port: String, + query_port: String, + page_port: String, + original_f10_and_same_s_t2_required: bool, + default_selection_is_original: bool, + new_envelope_selection_explicit: bool, + first_policy_source_bound: bool, + transport_counters_cumulative: bool, + outcomes_scoped_to_exact_envelope: bool, + natural_index_transaction_witness_required: bool, + existing_bytes_may_be_replaced: bool, + original_capture_requires_live_clock_or_grant: bool, + capture_or_query_grants_dispatch: bool, + physical_stock_effect: bool, + temporary_key_retained: bool, + provider_io_inside_sql: bool, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] struct NativeSellerStockAuthority { + rewrapping: StockRewrapping, delivery: StockDelivery, envelope_retention: StockEnvelopeRetention, qualified_local_recovery: QualifiedLocalRecovery, @@ -689,7 +734,7 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { envelope.journal_family == 10 && envelope.payload_version == 1 && envelope.payload_prefix_bytes == 213 - && envelope.supported_catalogs == [16, 17] + && envelope.supported_catalogs == [16, 17, 18] && envelope.retained_unsupported_catalogs == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] && envelope.raw_max_bytes == 65536 @@ -711,9 +756,52 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && !envelope.provider_io_inside_sql, "stock envelope retention drift", )?; + let rewrap = &stock.rewrapping; + require( + rewrap.journal_family == 14 + && rewrap.admission_journal_family == 13 + && rewrap.admission_payload_bytes == 248 + && rewrap.admission_window_seconds_max == 30 + && rewrap.admission_port == "InventoryStore.prepare_stock_rewrap" + && rewrap.admission_recovery_port == "InventoryStore.reconcile_stock_rewrap_admission" + && rewrap.admission_query_port == "InventoryStore.stock_rewrap_attempt" + && rewrap.explicit_request_id_required + && rewrap.newly_confirmed_admission_before_wrapping + && !rewrap.existing_or_uncertain_admission_grants_invocation + && rewrap.unknown_admissions_count_toward_limit + && rewrap.descriptor_includes_uncaptured_admissions + && !rewrap.admission_repair_grants_history_or_invocation + && rewrap.payload_version == 1 + && rewrap.payload_prefix_bytes == 117 + && rewrap.supported_catalogs == [18] + && rewrap.retained_unsupported_catalogs + == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] + && rewrap.raw_max_bytes == 65536 + && rewrap.worker_charge_bytes == 1048576 + && rewrap.additional_envelopes_per_recipient_max == 192 + && rewrap.descriptor_page_max == 16 + && rewrap.capture_port == "InventoryStore.capture_stock_rewrap" + && rewrap.recovery_port == "InventoryStore.reconcile_stock_rewrap" + && rewrap.query_port == "InventoryStore.stock_envelope" + && rewrap.page_port == "InventoryStore.stock_rewraps" + && rewrap.original_f10_and_same_s_t2_required + && rewrap.default_selection_is_original + && rewrap.new_envelope_selection_explicit + && rewrap.first_policy_source_bound + && rewrap.transport_counters_cumulative + && rewrap.outcomes_scoped_to_exact_envelope + && rewrap.natural_index_transaction_witness_required + && !rewrap.existing_bytes_may_be_replaced + && !rewrap.original_capture_requires_live_clock_or_grant + && !rewrap.capture_or_query_grants_dispatch + && !rewrap.physical_stock_effect + && !rewrap.temporary_key_retained + && !rewrap.provider_io_inside_sql, + "stock rewrapping authority or retention drift", + )?; let delivery = &stock.delivery; require( - delivery.supported_catalogs == [17] + delivery.supported_catalogs == [17, 18] && delivery.retained_unsupported_catalogs == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] && delivery.attempt_journal_family == 11 @@ -772,11 +860,11 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.scope == "seller_stock_owner" && stock.database == "stock_execution_v1.sqlite" && stock.lock == ".stock_execution_v1.lock" - && stock.schema_version == 17 + && stock.schema_version == 18 && stock.retained_enrollment_versions == [1] && stock.retained_inventory_versions - == [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] - && stock.authority_payload_schema == "radroots.seller_stock.authority.v17" + == [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] + && stock.authority_payload_schema == "radroots.seller_stock.authority.v18" && stock.public_source_payload_schemas == [ "radroots.seller_stock.public_source_event.v1", @@ -1055,7 +1143,7 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.qualified_local_recovery.native_authorizer == "NativeWorkspace.authorize_stock_exact_replay" && stock.qualified_local_recovery.captured_replay == "local_replay_safe" - && stock.qualified_local_recovery.native_catalog == 17 + && stock.qualified_local_recovery.native_catalog == 18 && stock.qualified_local_recovery.worker_charge_bytes == 1048576 && stock .qualified_local_recovery @@ -1118,7 +1206,7 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.preparation_abort.unsupported_hosts_return == "capability_unavailable" && stock.preparation_abort.retained_payload_versions == [1] && stock.preparation_abort.retained_v1_requires_absent_claims - && stock.preparation_abort.claimed_cleanup_catalogs == [15, 16, 17] + && stock.preparation_abort.claimed_cleanup_catalogs == [15, 16, 17, 18] && stock.preparation_abort.untracked_claimed_catalogs == [13, 14] && stock.preparation_abort.per_recipient_proof_count == 2 && stock @@ -2442,6 +2530,49 @@ mod tests { } #[test] + fn stock_rewrapping_cannot_replace_originals_reset_policy_or_invent_dispatch() { + for (field, bad) in [ + ("journal_family", json!(13)), + ("admission_journal_family", json!(14)), + ("admission_payload_bytes", json!(247)), + ("admission_window_seconds_max", json!(31)), + ("explicit_request_id_required", json!(false)), + ("newly_confirmed_admission_before_wrapping", json!(false)), + ( + "existing_or_uncertain_admission_grants_invocation", + json!(true), + ), + ("unknown_admissions_count_toward_limit", json!(false)), + ("descriptor_includes_uncaptured_admissions", json!(false)), + ("admission_repair_grants_history_or_invocation", json!(true)), + ("supported_catalogs", json!([17, 18])), + ("payload_prefix_bytes", json!(118)), + ("additional_envelopes_per_recipient_max", json!(193)), + ("descriptor_page_max", json!(17)), + ("default_selection_is_original", json!(false)), + ("new_envelope_selection_explicit", json!(false)), + ("first_policy_source_bound", json!(false)), + ("transport_counters_cumulative", json!(false)), + ("outcomes_scoped_to_exact_envelope", json!(false)), + ("natural_index_transaction_witness_required", json!(false)), + ("existing_bytes_may_be_replaced", json!(true)), + ("capture_or_query_grants_dispatch", json!(true)), + ("physical_stock_effect", json!(true)), + ("temporary_key_retained", json!(true)), + ("provider_io_inside_sql", json!(true)), + ] { + assert!( + validate_bytes(&changed( + &format!("/native_seller_stock_authority/rewrapping/{field}"), + bad + )) + .is_err(), + "{field}" + ); + } + } + + #[test] fn stock_envelope_retention_cannot_become_dispatch_permission_or_a_cache_authority() { for (field, bad) in [ ("journal_family", json!(9)),