lib

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

commit c95bfcdbd73c08dd3581b2c718862158314a50fc
parent dbd5245699aab199db35dda2421c2c28a102693f
Author: triesap <tyson@radroots.org>
Date:   Tue, 20 Oct 2026 18:13:46 +0000

storage: retain original public delivery and exact observations

- Share explicit public and private work under the existing owner.
- Retain original public bytes and independent target observations.
- Preserve private contexts and exact predecessor catalog recovery.
- Verify loopback faults, browser recovery, APIs and source policy.

Diffstat:
Mcontracts/api_baselines/radroots_event.txt | 2++
Mcontracts/api_baselines/radroots_storage.txt | 43++++++++++++++++++++++++++++++++++---------
Mcontracts/api_baselines/radroots_storage_indexeddb.wasm32_workspace.txt | 8++++----
Mcontracts/api_baselines/radroots_storage_sqlite.txt | 4++--
Mcrates/event/src/draft.rs | 88+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/execution/src/receipt.rs | 10++++++----
Mcrates/execution/src/session/inquiry.rs | 10+++++-----
Mcrates/execution/tests/support/workspace_commands.rs | 4++--
Mcrates/radroots/tests/receipts.rs | 3+++
Acrates/radroots/tests/support/legacy_delivery_catalog.rs | 83+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/radroots/tests/support/receipt_delivery.rs | 132++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
Mcrates/radroots/tests/support/receipt_delivery_admission.rs | 16++++++++++++----
Mcrates/radroots/tests/support/receipt_delivery_faults.rs | 25+++++++++++++------------
Mcrates/radroots/tests/support/receipt_installation.rs | 2+-
Acrates/radroots/tests/support/receipt_public_delivery.rs | 752+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/radroots/tests/support/receipt_workflow_faults.rs | 6++++--
Mcrates/storage/src/command.rs | 10++++++----
Mcrates/storage/src/command/delivery.rs | 131++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
Mcrates/storage/src/command/delivery_summary.rs | 6+++---
Mcrates/storage/src/command/observation.rs | 6+++---
Acrates/storage/src/command/publication.rs | 91+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage/src/command/snapshot.rs | 20+++++++++++++++-----
Mcrates/storage_indexeddb/src/workspace/delivery/observation_operations.rs | 16++++++++++------
Mcrates/storage_indexeddb/src/workspace/delivery/operations.rs | 17++++++++++-------
Mcrates/storage_indexeddb/src/workspace/issuance.rs | 10+++++-----
Mcrates/storage_indexeddb/src/workspace/ports.rs | 12++++++------
Mcrates/storage_indexeddb/src/workspace/recovery.rs | 4++--
Mcrates/storage_indexeddb/src/workspace/retained.rs | 2+-
Mcrates/storage_indexeddb/tests/browser/src/workspace/delivery.rs | 2+-
Mcrates/storage_indexeddb/tests/browser/src/workspace/observations.rs | 8++++----
Mcrates/storage_sqlite/src/workspace/attempt.rs | 15++++++++++-----
Mcrates/storage_sqlite/src/workspace/crypto.rs | 23++++++++++++++++++++---
Mcrates/storage_sqlite/src/workspace/delivery/codec.rs | 128++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------
Mcrates/storage_sqlite/src/workspace/delivery/codec_tests.rs | 156+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------
Mcrates/storage_sqlite/src/workspace/delivery/graph.rs | 92++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------
Mcrates/storage_sqlite/src/workspace/delivery/graph_tests.rs | 59+++++++++++++++++++++++++++++------------------------------
Mcrates/storage_sqlite/src/workspace/delivery/mod.rs | 45++++++++++++++++++++++++++++++++++++++++++---
Mcrates/storage_sqlite/src/workspace/delivery/observation.rs | 37++++++++++++++++++++++++++-----------
Mcrates/storage_sqlite/src/workspace/delivery/observation_operations.rs | 34++++++++++++++++++++++++++++++----
Mcrates/storage_sqlite/src/workspace/delivery/observation_tests.rs | 4++--
Mcrates/storage_sqlite/src/workspace/delivery/operations.rs | 89+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------
Mcrates/storage_sqlite/src/workspace/listing.rs | 2+-
Mcrates/storage_sqlite/src/workspace/listing_installation.rs | 4++--
Mcrates/storage_sqlite/src/workspace/mod.rs | 10+++++-----
Mcrates/storage_sqlite/src/workspace/snapshot.rs | 12++++++++++--
Mcrates/storage_sqlite/src/workspace/tests/issuance_records.rs | 151++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/tests/mod.rs | 8++++----
Mcrates/storage_sqlite/src/workspace/worker.rs | 65+++++++++++++++++++++++++++++++++++++++++++----------------------
Acrates/storage_sqlite/tests/support/legacy_delivery_catalog.rs | 83+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/tests/support/public_admission.rs | 157+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
50 files changed, 2384 insertions(+), 313 deletions(-)

diff --git a/contracts/api_baselines/radroots_event.txt b/contracts/api_baselines/radroots_event.txt @@ -548,6 +548,7 @@ pub fn radroots_event::draft::SignedEvent::content(&self) -> &str pub fn radroots_event::draft::SignedEvent::created_at(&self) -> u64 pub fn radroots_event::draft::SignedEvent::envelope(&self) -> &radroots_event::envelope::EventEnvelope pub fn radroots_event::draft::SignedEvent::from_wire_verified_id(Nip01EventWire, impl core::convert::Into<alloc::string::String>) -> core::result::Result<Self, radroots_event::draft::SignedEventError> +pub fn radroots_event::draft::SignedEvent::from_wire_verified_id_with_limits(Nip01EventWire, impl core::convert::Into<alloc::string::String>, crate::wire::EventWireLimits) -> core::result::Result<Self, radroots_event::draft::SignedEventError> pub fn radroots_event::draft::SignedEvent::id(&self) -> &radroots_event::id::EventId pub fn radroots_event::draft::SignedEvent::id_hex(&self) -> alloc::string::String pub fn radroots_event::draft::SignedEvent::id_str(&self) -> &str @@ -3587,6 +3588,7 @@ pub fn radroots_event::draft::SignedEvent::content(&self) -> &str pub fn radroots_event::draft::SignedEvent::created_at(&self) -> u64 pub fn radroots_event::draft::SignedEvent::envelope(&self) -> &radroots_event::envelope::EventEnvelope pub fn radroots_event::draft::SignedEvent::from_wire_verified_id(Nip01EventWire, impl core::convert::Into<alloc::string::String>) -> core::result::Result<Self, radroots_event::draft::SignedEventError> +pub fn radroots_event::draft::SignedEvent::from_wire_verified_id_with_limits(Nip01EventWire, impl core::convert::Into<alloc::string::String>, crate::wire::EventWireLimits) -> core::result::Result<Self, radroots_event::draft::SignedEventError> pub fn radroots_event::draft::SignedEvent::id(&self) -> &radroots_event::id::EventId pub fn radroots_event::draft::SignedEvent::id_hex(&self) -> alloc::string::String pub fn radroots_event::draft::SignedEvent::id_str(&self) -> &str diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -867,6 +867,25 @@ pub radroots_storage::command::PlanBindingOutcome::Committed(radroots_storage::c pub radroots_storage::command::PlanBindingOutcome::Unknown(radroots_storage::command::CommitAttempt) impl core::fmt::Debug for radroots_storage::command::PlanBindingOutcome pub fn radroots_storage::command::PlanBindingOutcome::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub enum radroots_storage::command::PublicationArtifact +pub radroots_storage::command::PublicationArtifact::Private(radroots_storage::command::PublicationWork) +pub radroots_storage::command::PublicationArtifact::Public(radroots_storage::command::PublicPublicationWork) +impl radroots_storage::command::PublicationArtifact +pub const fn radroots_storage::command::PublicationArtifact::evidence(self) -> radroots_storage::command::EvidenceReceipt +pub const fn radroots_storage::command::PublicationArtifact::installation_transaction_id(self) -> radroots_domain::identifier::TransactionId +pub const fn radroots_storage::command::PublicationArtifact::plan_digest(&self) -> &[u8; 32] +pub fn radroots_storage::command::PublicationArtifact::private(self) -> core::result::Result<radroots_storage::command::PublicationWork, radroots_storage::command::OperationError> +pub fn radroots_storage::command::PublicationArtifact::public(self) -> core::result::Result<radroots_storage::command::PublicPublicationWork, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::PublicationArtifact::queued_at(self) -> radroots_domain::context::UnixSeconds +pub const fn radroots_storage::command::PublicationArtifact::recipient(self) -> core::option::Option<radroots_identity::key::PublicKey> +pub const fn radroots_storage::command::PublicationArtifact::target(self) -> radroots_protocol::plan::SigningTarget +pub const fn radroots_storage::command::PublicationArtifact::transaction_id(self) -> radroots_domain::identifier::TransactionId +impl core::convert::From<radroots_storage::command::PublicPublicationWork> for radroots_storage::command::PublicationArtifact +pub fn radroots_storage::command::PublicationArtifact::from(radroots_storage::command::PublicPublicationWork) -> Self +impl core::convert::From<radroots_storage::command::PublicationWork> for radroots_storage::command::PublicationArtifact +pub fn radroots_storage::command::PublicationArtifact::from(radroots_storage::command::PublicationWork) -> Self +impl core::fmt::Debug for radroots_storage::command::PublicationArtifact +pub fn radroots_storage::command::PublicationArtifact::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub enum radroots_storage::command::RetainedOperation pub radroots_storage::command::RetainedOperation::Planned(alloc::boxed::Box<radroots_storage::command::BoundSigningPlan>) pub radroots_storage::command::RetainedOperation::Prepared(radroots_storage::command::PreparedOperation) @@ -988,14 +1007,14 @@ pub const fn radroots_storage::command::CommitAttempt::workspace_id(self) -> rad pub struct radroots_storage::command::DeliveryAttempt impl radroots_storage::command::DeliveryAttempt pub const fn radroots_storage::command::DeliveryAttempt::envelope_digest(&self) -> &[u8; 32] -pub fn radroots_storage::command::DeliveryAttempt::from_store_report(radroots_storage::command::PublicationWork, radroots_storage::command::DeliveryIntent, &str, radroots_domain::identifier::TransactionId, radroots_domain::context::UnixSeconds, alloc::vec::Vec<u8>) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::command::DeliveryAttempt::from_store_report(impl core::convert::Into<radroots_storage::command::PublicationArtifact>, radroots_storage::command::DeliveryIntent, &str, radroots_domain::identifier::TransactionId, radroots_domain::context::UnixSeconds, alloc::vec::Vec<u8>) -> core::result::Result<Self, radroots_storage::command::OperationError> pub const fn radroots_storage::command::DeliveryAttempt::intent(&self) -> &radroots_storage::command::DeliveryIntent pub fn radroots_storage::command::DeliveryAttempt::raw_json(&self) -> &str pub const fn radroots_storage::command::DeliveryAttempt::retained_at(&self) -> radroots_domain::context::UnixSeconds pub fn radroots_storage::command::DeliveryAttempt::target_ordinals(&self) -> &[u8] pub const fn radroots_storage::command::DeliveryAttempt::transaction_id(&self) -> radroots_domain::identifier::TransactionId pub fn radroots_storage::command::DeliveryAttempt::transport_request(&self) -> core::result::Result<radroots_transport::sink::DeliveryRequest, radroots_storage::command::OperationError> -pub const fn radroots_storage::command::DeliveryAttempt::work(&self) -> radroots_storage::command::PublicationWork +pub const fn radroots_storage::command::DeliveryAttempt::work(&self) -> radroots_storage::command::PublicationArtifact impl core::fmt::Debug for radroots_storage::command::DeliveryAttempt pub fn radroots_storage::command::DeliveryAttempt::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::DeliveryAttemptRequest @@ -1003,8 +1022,8 @@ impl radroots_storage::command::DeliveryAttemptRequest pub const fn radroots_storage::command::DeliveryAttemptRequest::binding(&self) -> &radroots_storage::workspace::WorkspaceBinding pub fn radroots_storage::command::DeliveryAttemptRequest::identity(&self) -> radroots_storage::command::CommitAttempt pub const fn radroots_storage::command::DeliveryAttemptRequest::intent(&self) -> &radroots_storage::command::DeliveryIntent -pub fn radroots_storage::command::DeliveryAttemptRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::command::PublicationWork, radroots_storage::command::DeliveryIntent) -> core::result::Result<Self, radroots_storage::command::OperationError> -pub const fn radroots_storage::command::DeliveryAttemptRequest::work(&self) -> radroots_storage::command::PublicationWork +pub fn radroots_storage::command::DeliveryAttemptRequest::new(radroots_storage::workspace::WorkspaceBinding, impl core::convert::Into<radroots_storage::command::PublicationArtifact>, radroots_storage::command::DeliveryIntent) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::DeliveryAttemptRequest::work(&self) -> radroots_storage::command::PublicationArtifact impl core::fmt::Debug for radroots_storage::command::DeliveryAttemptRequest pub fn radroots_storage::command::DeliveryAttemptRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::DeliveryAttemptSummary @@ -1016,7 +1035,7 @@ pub const fn radroots_storage::command::DeliveryAttemptSummary::intent(&self) -> pub const fn radroots_storage::command::DeliveryAttemptSummary::retained_at(&self) -> radroots_domain::context::UnixSeconds pub fn radroots_storage::command::DeliveryAttemptSummary::target_ordinals(&self) -> &[u8] pub const fn radroots_storage::command::DeliveryAttemptSummary::transaction_id(&self) -> radroots_domain::identifier::TransactionId -pub const fn radroots_storage::command::DeliveryAttemptSummary::work(&self) -> radroots_storage::command::PublicationWork +pub const fn radroots_storage::command::DeliveryAttemptSummary::work(&self) -> radroots_storage::command::PublicationArtifact impl core::fmt::Debug for radroots_storage::command::DeliveryAttemptSummary pub fn radroots_storage::command::DeliveryAttemptSummary::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::DeliveryIntent @@ -1026,8 +1045,10 @@ pub const fn radroots_storage::command::DeliveryIntent::digest(&self) -> &[u8; 3 pub const fn radroots_storage::command::DeliveryIntent::event_id(&self) -> radroots_domain::identifier::EnvelopeEventId pub fn radroots_storage::command::DeliveryIntent::new(&str, radroots_domain::identifier::EnvelopeEventId, &radroots_transport::target::TargetSet, &radroots_transport::policy::SatisfactionPolicy, core::num::nonzero::NonZeroU64) -> core::result::Result<Self, radroots_storage::command::OperationError> pub const fn radroots_storage::command::DeliveryIntent::policy(&self) -> &radroots_transport::policy::SatisfactionPolicy +pub fn radroots_storage::command::DeliveryIntent::public(&str, radroots_domain::identifier::EnvelopeEventId, &radroots_transport::target::TargetSet, &radroots_transport::policy::SatisfactionPolicy, core::num::nonzero::NonZeroU64) -> core::result::Result<Self, radroots_storage::command::OperationError> pub const fn radroots_storage::command::DeliveryIntent::publication_policy_digest(&self) -> &[u8; 32] pub const fn radroots_storage::command::DeliveryIntent::request_id(&self) -> &radroots_transport::sink::DeliveryRequestId +pub const fn radroots_storage::command::DeliveryIntent::role(&self) -> radroots_protocol::intent::ArtifactRole pub fn radroots_storage::command::DeliveryIntent::selected_target_set(&self) -> core::result::Result<radroots_transport::target::TargetSet, radroots_storage::command::OperationError> pub fn radroots_storage::command::DeliveryIntent::selected_targets(&self) -> impl core::iter::traits::iterator::Iterator<Item = &radroots_transport::target::Target> pub fn radroots_storage::command::DeliveryIntent::selection(&self) -> &[radroots_transport::target::TargetFingerprint] @@ -1047,7 +1068,7 @@ pub const fn radroots_storage::command::DeliveryObservation::observed_at_unix_ms pub const fn radroots_storage::command::DeliveryObservation::request_id(&self) -> &radroots_transport::sink::DeliveryRequestId pub const fn radroots_storage::command::DeliveryObservation::target_ordinal(&self) -> u8 pub const fn radroots_storage::command::DeliveryObservation::target_receipt(&self) -> &radroots_transport::sink::DeliveryTargetReceipt -pub const fn radroots_storage::command::DeliveryObservation::work(&self) -> radroots_storage::command::PublicationWork +pub const fn radroots_storage::command::DeliveryObservation::work(&self) -> radroots_storage::command::PublicationArtifact impl core::fmt::Debug for radroots_storage::command::DeliveryObservation pub fn radroots_storage::command::DeliveryObservation::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::EnvelopeCandidate @@ -1118,7 +1139,7 @@ pub fn radroots_storage::command::OperationSnapshot::message_id(&self) -> core:: pub const fn radroots_storage::command::OperationSnapshot::observed_at(&self) -> radroots_domain::context::UnixSeconds pub fn radroots_storage::command::OperationSnapshot::prepared(&self) -> &radroots_storage::command::PreparedOperation pub fn radroots_storage::command::OperationSnapshot::public_publications(&self) -> &[radroots_storage::command::PublicPublicationWork] -pub fn radroots_storage::command::OperationSnapshot::publication_accepted(&self, radroots_storage::command::PublicationWork) -> core::result::Result<bool, radroots_storage::command::OperationError> +pub fn radroots_storage::command::OperationSnapshot::publication_accepted(&self, impl core::convert::Into<radroots_storage::command::PublicationArtifact>) -> core::result::Result<bool, radroots_storage::command::OperationError> pub fn radroots_storage::command::OperationSnapshot::publications(&self) -> &[radroots_storage::command::PublicationWork] pub fn radroots_storage::command::OperationSnapshot::with_delivery(self, alloc::vec::Vec<radroots_storage::command::DeliveryAttemptSummary>, alloc::vec::Vec<radroots_storage::command::DeliveryObservation>) -> core::result::Result<Self, radroots_storage::command::OperationError> pub fn radroots_storage::command::OperationSnapshot::with_installation(self, core::option::Option<radroots_storage::command::ChatInstallation>, alloc::vec::Vec<radroots_storage::command::PublicationWork>) -> core::result::Result<Self, radroots_storage::command::OperationError> @@ -1143,6 +1164,8 @@ pub const fn radroots_storage::command::PublicPublicationWork::installation_tran pub const fn radroots_storage::command::PublicPublicationWork::plan_digest(&self) -> &[u8; 32] pub const fn radroots_storage::command::PublicPublicationWork::queued_at(&self) -> radroots_domain::context::UnixSeconds pub const fn radroots_storage::command::PublicPublicationWork::transaction_id(&self) -> radroots_domain::identifier::TransactionId +impl core::convert::From<radroots_storage::command::PublicPublicationWork> for radroots_storage::command::PublicationArtifact +pub fn radroots_storage::command::PublicationArtifact::from(radroots_storage::command::PublicPublicationWork) -> Self impl core::fmt::Debug for radroots_storage::command::PublicPublicationWork pub fn radroots_storage::command::PublicPublicationWork::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::PublicationWork @@ -1154,6 +1177,8 @@ pub const fn radroots_storage::command::PublicationWork::plan_digest(&self) -> & pub const fn radroots_storage::command::PublicationWork::queued_at(&self) -> radroots_domain::context::UnixSeconds pub const fn radroots_storage::command::PublicationWork::recipient(&self) -> radroots_identity::key::PublicKey pub const fn radroots_storage::command::PublicationWork::transaction_id(&self) -> radroots_domain::identifier::TransactionId +impl core::convert::From<radroots_storage::command::PublicationWork> for radroots_storage::command::PublicationArtifact +pub fn radroots_storage::command::PublicationArtifact::from(radroots_storage::command::PublicationWork) -> Self impl core::fmt::Debug for radroots_storage::command::PublicationWork pub fn radroots_storage::command::PublicationWork::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::SignedDmRelaySource @@ -1188,8 +1213,8 @@ pub fn radroots_storage::command::OperationJournal::admit_command_and_hold(&self pub fn radroots_storage::command::OperationJournal::bind_signing_intents(&self, radroots_storage::workspace::WorkspaceBinding, radroots_protocol::plan::CapturedSigningPlan, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::PlanBindingOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::capture_evidence<'a>(&'a self, radroots_storage::workspace::AttachmentInput, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::ArtifactEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::claim_attempt(&self, radroots_storage::command::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::ClaimAttemptOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage::command::OperationJournal::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::DeliveryAttempt>, radroots_storage::command::OperationError>> -pub fn radroots_storage::command::OperationJournal::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<alloc::vec::Vec<radroots_storage::command::DeliveryObservation>, radroots_storage::command::OperationError>> +pub fn radroots_storage::command::OperationJournal::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::DeliveryAttempt>, radroots_storage::command::OperationError>> +pub fn radroots_storage::command::OperationJournal::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<alloc::vec::Vec<radroots_storage::command::DeliveryObservation>, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::install_transition_and_outbox(&self, radroots_storage::command::InstallationRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::InstallationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::obtained_evidence(&self, radroots_storage::command::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::CapturedArtifact>, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::operation(&self, radroots_storage::workspace::WorkspaceBinding, 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::command::PreparedOperation>, radroots_storage::command::OperationError>> diff --git a/contracts/api_baselines/radroots_storage_indexeddb.wasm32_workspace.txt b/contracts/api_baselines/radroots_storage_indexeddb.wasm32_workspace.txt @@ -20,10 +20,10 @@ pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::open_exist pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::open_existing_for_capture(radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof, alloc::rc::Rc<dyn radroots_secrets::provider::SecretProvider>, radroots_secrets::id::SecretRef, radroots_secrets::provider::AccessPolicy, alloc::rc::Rc<dyn radroots_storage::workspace::WorkspaceClock>) -> core::result::Result<Self, radroots_storage::workspace::WorkspaceError> pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::revoke(&self, radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof) -> core::result::Result<(), radroots_storage::workspace::WorkspaceError> impl radroots_storage_indexeddb::workspace::BrowserWorkspace -pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::command::delivery::DeliveryAttempt>, radroots_storage::command::OperationError> +pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::command::delivery::DeliveryAttempt>, radroots_storage::command::OperationError> pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::prepare_delivery_attempt(&self, radroots_storage::command::delivery::DeliveryAttemptRequest, radroots_storage::workspace::AttachmentProof, core::option::Option<&radroots_storage::command::delivery::EnvelopeCandidate>) -> core::result::Result<radroots_storage::command::delivery::DeliveryAttemptOutcome, radroots_storage::command::OperationError> impl radroots_storage_indexeddb::workspace::BrowserWorkspace -pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> core::result::Result<alloc::vec::Vec<radroots_storage::command::observation::DeliveryObservation>, radroots_storage::command::OperationError> +pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> core::result::Result<alloc::vec::Vec<radroots_storage::command::observation::DeliveryObservation>, radroots_storage::command::OperationError> pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::record_delivery_observation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::AttachmentProof, radroots_storage::command::observation::DeliveryObservation) -> core::result::Result<radroots_storage::command::observation::DeliveryObservationOutcome, radroots_storage::command::OperationError> impl radroots_storage_indexeddb::workspace::BrowserWorkspace pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::install_transition_and_outbox(&self, radroots_storage::command::installation::InstallationRequest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::command::installation::InstallationOutcome, radroots_storage::command::OperationError> @@ -35,8 +35,8 @@ pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::admit_command_an pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::bind_signing_intents(&self, radroots_storage::workspace::WorkspaceBinding, radroots_protocol::plan::CapturedSigningPlan, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::PlanBindingOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::capture_evidence<'a>(&'a self, radroots_storage::workspace::AttachmentInput, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::issuance::ArtifactEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::claim_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::issuance::ClaimAttemptOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::delivery::DeliveryAttempt>, radroots_storage::command::OperationError>> -pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<alloc::vec::Vec<radroots_storage::command::observation::DeliveryObservation>, radroots_storage::command::OperationError>> +pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::delivery::DeliveryAttempt>, radroots_storage::command::OperationError>> +pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<alloc::vec::Vec<radroots_storage::command::observation::DeliveryObservation>, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::install_transition_and_outbox(&self, radroots_storage::command::installation::InstallationRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::installation::InstallationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::obtained_evidence(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::issuance::CapturedArtifact>, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::operation(&self, radroots_storage::workspace::WorkspaceBinding, 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::command::PreparedOperation>, radroots_storage::command::OperationError>> diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -381,8 +381,8 @@ pub fn radroots_storage_sqlite::workspace::NativeWorkspace::admit_command_and_ho pub fn radroots_storage_sqlite::workspace::NativeWorkspace::bind_signing_intents(&self, radroots_storage::workspace::WorkspaceBinding, radroots_protocol::plan::CapturedSigningPlan, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::PlanBindingOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::capture_evidence<'a>(&'a self, radroots_storage::workspace::AttachmentInput, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::issuance::ArtifactEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::claim_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::issuance::ClaimAttemptOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage_sqlite::workspace::NativeWorkspace::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::delivery::DeliveryAttempt>, radroots_storage::command::OperationError>> -pub fn radroots_storage_sqlite::workspace::NativeWorkspace::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_identity::key::PublicKey, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<alloc::vec::Vec<radroots_storage::command::observation::DeliveryObservation>, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::delivery_attempt(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::delivery::DeliveryAttempt>, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::delivery_observations(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_protocol::plan::SigningTarget, radroots_transport::sink::DeliveryRequestId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<alloc::vec::Vec<radroots_storage::command::observation::DeliveryObservation>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::install_transition_and_outbox(&self, radroots_storage::command::installation::InstallationRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::installation::InstallationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::obtained_evidence(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::issuance::CapturedArtifact>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::operation(&self, radroots_storage::workspace::WorkspaceBinding, 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::command::PreparedOperation>, radroots_storage::command::OperationError>> diff --git a/crates/event/src/draft.rs b/crates/event/src/draft.rs @@ -251,6 +251,45 @@ impl SignedEvent { }) } + /// Checks exact raw/wire containment and the canonical ID under explicit + /// caller-owned bounds. Signature verification remains a separate step. + /// The legacy constructor and its default profile remain unchanged. + pub fn from_wire_verified_id_with_limits( + wire: Nip01EventWire, + raw_json: impl Into<String>, + limits: crate::wire::EventWireLimits, + ) -> Result<Self, SignedEventError> { + let raw_json = raw_json.into(); + let parsed = Nip01EventWire::parse_json_with_limits(&raw_json, limits) + .map_err(SignedEventError::RawJson)?; + crate::require_invariant(parsed == wire, &|| SignedEventError::RawJsonMismatch)?; + wire.verify_id().map_err(SignedEventError::Wire)?; + let envelope = EventEnvelope::new_with_limits( + crate::envelope::EventEnvelopeParts { + id: wire.id.clone(), + author: wire.pubkey.clone(), + created_at: wire.created_at, + kind: wire.kind, + tags: wire.tags.clone(), + content: wire.content.clone(), + sig: wire.sig.clone(), + }, + crate::envelope::EventEnvelopeLimits { + max_content_bytes: limits.max_content_bytes, + max_tag_count: limits.max_tag_count, + max_total_tag_elements: limits.max_total_tag_elements, + max_tag_element_bytes: limits.max_tag_element_bytes, + max_total_tag_bytes: limits.max_total_tag_bytes, + }, + ) + .map_err(SignedEventError::Envelope)?; + Ok(Self { + envelope, + wire, + raw_json, + }) + } + #[inline] pub fn envelope(&self) -> &EventEnvelope { &self.envelope @@ -438,6 +477,55 @@ mod tests { } #[test] + fn explicit_wire_budget_preserves_exact_raw_and_default_limits_remain_unchanged() { + let mut wire = verified_wire("public content"); + wire.tags = vec![vec!["radroots:listing".into(), "x".repeat(4097)]]; + wire.id = compute_canonical_nip01_event_id( + &wire.pubkey, + wire.created_at, + wire.kind, + &wire.tags, + &wire.content, + ) + .unwrap() + .into_string(); + let raw = format!(" \n{} \t", raw_json_for_wire(&wire)); + assert!(SignedEvent::from_wire_verified_id(wire.clone(), raw.clone()).is_err()); + let limits = crate::wire::EventWireLimits { + max_raw_json_bytes: raw.len(), + max_tag_element_bytes: 4097, + ..Default::default() + }; + let event = + SignedEvent::from_wire_verified_id_with_limits(wire.clone(), raw.clone(), limits) + .unwrap(); + assert_eq!(event.raw_json(), raw); + assert_eq!(event.wire(), &wire); + assert_eq!(event.envelope().tags_as_vec(), wire.tags); + for reduced in [ + crate::wire::EventWireLimits { + max_raw_json_bytes: raw.len() - 1, + ..limits + }, + crate::wire::EventWireLimits { + max_tag_element_bytes: 4096, + ..limits + }, + ] { + assert!( + SignedEvent::from_wire_verified_id_with_limits(wire.clone(), raw.clone(), reduced) + .is_err() + ); + } + let other = verified_wire("different exact input"); + assert_eq!( + SignedEvent::from_wire_verified_id_with_limits(wire, raw_json_for_wire(&other), limits) + .unwrap_err(), + SignedEventError::RawJsonMismatch + ); + } + + #[test] fn signed_event_rejects_noncanonical_or_mismatched_wire() { let wire = verified_wire("hello"); let raw_json = raw_json_for_wire(&wire); diff --git a/crates/execution/src/receipt.rs b/crates/execution/src/receipt.rs @@ -604,10 +604,12 @@ impl OperationReceipt<ChatMessage> { } else if delivery_unknown { Delivery::Unknown } else if attempts.is_empty() - || snapshot - .publications() - .iter() - .any(|work| !attempts.iter().any(|attempt| attempt.work() == *work)) + || snapshot.publications().iter().any(|work| { + !attempts.iter().any(|attempt| { + attempt.work() + == radroots_storage::command::PublicationArtifact::Private(*work) + }) + }) { Delivery::Pending } else { diff --git a/crates/execution/src/session/inquiry.rs b/crates/execution/src/session/inquiry.rs @@ -445,10 +445,9 @@ impl InquiryRuntime { continue; } // Replaying a command never dispatches a previously claimed attempt. - let original = snapshot - .delivery_attempts() - .iter() - .find(|attempt| attempt.work() == *work); + let original = snapshot.delivery_attempts().iter().find(|attempt| { + attempt.work() == radroots_storage::command::PublicationArtifact::Private(*work) + }); if original.is_some() && matches!(mode, RunMode::Command) { continue; } @@ -506,7 +505,8 @@ impl InquiryRuntime { .iter() .filter(|target| { !snapshot.delivery_observations().iter().any(|observation| { - observation.work() == *work + observation.work() + == radroots_storage::command::PublicationArtifact::Private(*work) && observation.target_receipt().target().fingerprint() == target.fingerprint() && observation.kind() diff --git a/crates/execution/tests/support/workspace_commands.rs b/crates/execution/tests/support/workspace_commands.rs @@ -93,7 +93,7 @@ impl OperationJournal for Journal { _binding: WorkspaceBinding, _operation: radroots_domain::OperationId, _digest: radroots_domain::CommandDigest, - _recipient: radroots_domain::PublicKey, + _target: radroots_storage::command::SigningTarget, _request: radroots_transport::sink::DeliveryRequestId, _proof: AttachmentProof, ) -> BoxFuture<'_, Result<Vec<DeliveryObservation>, OperationError>> { @@ -112,7 +112,7 @@ impl OperationJournal for Journal { _binding: WorkspaceBinding, _operation: OperationId, _digest: CommandDigest, - _recipient: radroots_domain::PublicKey, + _target: radroots_storage::command::SigningTarget, _request: radroots_transport::sink::DeliveryRequestId, _proof: AttachmentProof, ) -> BoxFuture<'_, Result<Option<DeliveryAttempt>, OperationError>> { diff --git a/crates/radroots/tests/receipts.rs b/crates/radroots/tests/receipts.rs @@ -9,6 +9,9 @@ mod ordinary; #[path = "support/receipt_workflow.rs"] mod workflow; +#[path = "support/receipt_public_delivery.rs"] +mod public_delivery; + use radroots_domain::{ CommandContextData, CommandDigest, CorrelationId, OperationId, PublicKey, UnixSeconds, }; diff --git a/crates/radroots/tests/support/legacy_delivery_catalog.rs b/crates/radroots/tests/support/legacy_delivery_catalog.rs @@ -0,0 +1,83 @@ +use sqlx::SqliteConnection; + +// Synthetic exact predecessor catalog, never a claim that an old binary ran. +pub(super) async fn retain_legacy_delivery_catalog(db: &mut SqliteConnection) { + use sqlx::Row; + let public: i64 = sqlx::query_scalar( + "SELECT count(*) FROM artifact_delivery_attempts WHERE length(artifact_key)!=32", + ) + .fetch_one(&mut *db) + .await + .unwrap(); + assert_eq!(public, 0); + let rows=sqlx::query("SELECT name,sql FROM sqlite_schema WHERE name IN ('artifact_delivery_attempts','artifact_delivery_parts','artifact_delivery_observations','artifact_delivery_transaction_identity')").fetch_all(&mut *db).await.unwrap(); + let definitions = rows + .into_iter() + .map(|row| { + let name: String = row.get(0); + let ddl: String = row.get(1); + let ddl = ddl + .replace("artifact_delivery", "chat_delivery") + .replace("artifact_key", "recipient") + .replace( + "CHECK(length(recipient)=32 OR (length(recipient)=1 AND hex(recipient)='00'))", + "CHECK(length(recipient)=32)", + ) + .replace( + "REFERENCES artifact_evidence(workspace,operation_id,recipient)", + "REFERENCES chat_publication_work(workspace,operation_id,recipient)", + ); + (name, ddl) + }) + .collect::<std::collections::BTreeMap<_, _>>(); + for table in [ + "artifact_delivery_attempts", + "artifact_delivery_parts", + "artifact_delivery_observations", + ] { + sqlx::query(sqlx::AssertSqlSafe(format!( + "CREATE TEMP TABLE retained_{table} AS SELECT * FROM {table}" + ))) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "artifact_delivery_observations", + "artifact_delivery_parts", + "artifact_delivery_attempts", + ] { + sqlx::query(sqlx::AssertSqlSafe(format!("DROP TABLE {table}"))) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "artifact_delivery_attempts", + "artifact_delivery_transaction_identity", + "artifact_delivery_parts", + "artifact_delivery_observations", + ] { + sqlx::query(sqlx::AssertSqlSafe(definitions[table].clone())) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "artifact_delivery_attempts", + "artifact_delivery_parts", + "artifact_delivery_observations", + ] { + let legacy = table.replace("artifact_delivery", "chat_delivery"); + sqlx::query(sqlx::AssertSqlSafe(format!( + "INSERT INTO {legacy} SELECT * FROM retained_{table}" + ))) + .execute(&mut *db) + .await + .unwrap(); + sqlx::query(sqlx::AssertSqlSafe(format!("DROP TABLE retained_{table}"))) + .execute(&mut *db) + .await + .unwrap(); + } +} diff --git a/crates/radroots/tests/support/receipt_delivery.rs b/crates/radroots/tests/support/receipt_delivery.rs @@ -236,7 +236,7 @@ impl Ready { self.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient().unwrap(), + e.target(), id.clone(), copy(&self.proof), ) @@ -255,7 +255,7 @@ impl Ready { self.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient().unwrap(), + e.target(), id.clone(), copy(&self.proof), ) @@ -442,7 +442,7 @@ async fn predecessor_schema_six_preserves_original_installation_and_seal_without let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 236).await; ready.store.close().await.unwrap(); let mut database = ready.fixture.database().await; - sqlx::raw_sql("DROP TABLE public_publication_work; DROP TABLE listing_installations; DROP TABLE listing_creations; DROP TABLE chat_delivery_observations; DROP TABLE chat_delivery_parts; DROP TABLE chat_delivery_attempts; PRAGMA user_version=6").execute(&mut database).await.unwrap(); + sqlx::raw_sql("DROP TABLE public_publication_work; DROP TABLE listing_installations; DROP TABLE listing_creations; DROP TABLE artifact_delivery_observations; DROP TABLE artifact_delivery_parts; DROP TABLE artifact_delivery_attempts; PRAGMA user_version=6").execute(&mut database).await.unwrap(); let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM sqlite_schema),(SELECT count(*) FROM chat_messages),(SELECT count(*) FROM artifact_evidence)").fetch_one(&mut database).await.unwrap(); assert_eq!(counts, (16, 1, 1)); database.close().await.unwrap(); @@ -496,7 +496,7 @@ async fn native_retry_reuses_exact_bytes_and_enforces_twelve_potential_attempts_ async fn actual_delivery_part_failure_rolls_back_attempt_and_keeps_original_installation() { let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 232).await; let mut database = ready.fixture.database().await; - sqlx::raw_sql("CREATE TRIGGER refuse_delivery_part BEFORE INSERT ON chat_delivery_parts BEGIN SELECT RAISE(ABORT,'synthetic part failure'); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TRIGGER refuse_delivery_part BEFORE INSERT ON artifact_delivery_parts BEGIN SELECT RAISE(ABORT,'synthetic part failure'); END").execute(&mut database).await.unwrap(); assert!(matches!( ready .store @@ -504,7 +504,7 @@ async fn actual_delivery_part_failure_rolls_back_attempt_and_keeps_original_inst .await, Err(OperationError::StorageFailure) )); - let counts:(i64,i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM chat_delivery_attempts),(SELECT count(*) FROM chat_delivery_parts),(SELECT count(*) FROM chat_messages),(SELECT count(*) FROM artifact_evidence)").fetch_one(&mut database).await.unwrap(); + let counts:(i64,i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM artifact_delivery_attempts),(SELECT count(*) FROM artifact_delivery_parts),(SELECT count(*) FROM chat_messages),(SELECT count(*) FROM artifact_evidence)").fetch_one(&mut database).await.unwrap(); assert_eq!(counts, (0, 0, 1, 1)); sqlx::query("DROP TRIGGER refuse_delivery_part") .execute(&mut database) @@ -521,7 +521,7 @@ async fn actual_delivery_commit_uncertainty_latches_and_reopen_preserves_busines let request = ready.request(1); let id = request.intent().request_id().clone(); let mut database = ready.fixture.database().await; - sqlx::raw_sql("CREATE TABLE delivery_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER delivery_commit_fault_trigger AFTER INSERT ON chat_delivery_attempts BEGIN INSERT INTO delivery_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TABLE delivery_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER delivery_commit_fault_trigger AFTER INSERT ON artifact_delivery_attempts BEGIN INSERT INTO delivery_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); database.close().await.unwrap(); let DeliveryAttemptOutcome::Unknown { operation, attempt } = ready .store @@ -545,7 +545,7 @@ async fn actual_delivery_commit_uncertainty_latches_and_reopen_preserves_busines ready.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient().unwrap(), + e.target(), id.clone(), copy(&ready.proof) ) @@ -566,7 +566,7 @@ async fn actual_delivery_commit_uncertainty_latches_and_reopen_preserves_busines ready.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient().unwrap(), + e.target(), id, copy(&ready.proof) ) @@ -664,3 +664,119 @@ async fn late_observation_append_requires_original_credential_but_no_fresh_clock ); reopened.close().await.unwrap(); } + +#[path = "legacy_delivery_catalog.rs"] +mod legacy_delivery_catalog; + +#[tokio::test] +async fn exact_generation_ten_reopens_private_delivery_bytes_and_continues_without_reencoding() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 236).await; + let first = ready.retain(1).await; + let evidence = ready.work.evidence(); + let checkpoint = ready + .store + .operation_snapshot( + ready.binding.clone(), + evidence.operation_id(), + None, + copy(&ready.proof), + ) + .await + .unwrap() + .unwrap() + .checkpoint_digest(); + ready.store.close().await.unwrap(); + let mut db = ready.fixture.database().await; + legacy_delivery_catalog::retain_legacy_delivery_catalog(&mut db).await; + sqlx::query("PRAGMA user_version=10") + .execute(&mut db) + .await + .unwrap(); + let catalog: Vec<(String, String)> = sqlx::query_as( + "SELECT name,sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%' ORDER BY name", + ) + .fetch_all(&mut db) + .await + .unwrap(); + let protected:Vec<Vec<u8>>=sqlx::query_scalar("SELECT protected FROM chat_delivery_attempts UNION ALL SELECT protected FROM chat_delivery_parts").fetch_all(&mut db).await.unwrap(); + db.close().await.unwrap(); + let reopened = ready.fixture.reopen(ready.input.clone()).await; + let retained = reopened + .delivery_attempt( + ready.binding.clone(), + evidence.operation_id(), + evidence.command_digest(), + evidence.target(), + first.intent().request_id().clone(), + copy(&ready.proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(retained.raw_json(), first.raw_json()); + assert_eq!(retained.transaction_id(), first.transaction_id()); + assert_eq!(retained.intent().digest(), first.intent().digest()); + let snapshot = reopened + .operation_snapshot( + ready.binding.clone(), + evidence.operation_id(), + None, + copy(&ready.proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(snapshot.checkpoint_digest(), checkpoint); + assert!(matches!( + reopened + .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) + .await + .unwrap(), + DeliveryAttemptOutcome::Retained(_) + )); + let second = match reopened + .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None) + .await + .unwrap() + { + DeliveryAttemptOutcome::Claimed(v) => v, + _ => panic!("fresh explicit private retry"), + }; + assert_eq!(second.raw_json(), first.raw_json()); + assert_eq!(second.target_ordinals(), &[2]); + let request = second.transport_request().unwrap(); + let failure = radroots_transport::SinkFailure::transport_closed(&request); + let observation = DeliveryObservation::from_failure( + &second, + &failure, + request.target_set().targets()[0].fingerprint(), + None, + ) + .unwrap(); + assert!(matches!( + reopened + .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation) + .await + .unwrap(), + DeliveryObservationOutcome::Committed(_) + )); + reopened.close().await.unwrap(); + let mut db = ready.fixture.database().await; + let actual: Vec<(String, String)> = sqlx::query_as( + "SELECT name,sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%' ORDER BY name", + ) + .fetch_all(&mut db) + .await + .unwrap(); + assert_eq!(actual, catalog); + let current:Vec<Vec<u8>>=sqlx::query_scalar("SELECT protected FROM chat_delivery_attempts UNION ALL SELECT protected FROM chat_delivery_parts").fetch_all(&mut db).await.unwrap(); + assert!(protected.iter().all(|v| current.contains(v))); + assert_eq!( + sqlx::query_scalar::<_, i64>("PRAGMA user_version") + .fetch_one(&mut db) + .await + .unwrap(), + 10 + ); + db.close().await.unwrap(); +} diff --git a/crates/radroots/tests/support/receipt_delivery_admission.rs b/crates/radroots/tests/support/receipt_delivery_admission.rs @@ -393,7 +393,7 @@ async fn native_delivery_refuses_backward_clock_expired_attempt_and_unbound_obse ready.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient().unwrap(), + e.target(), DeliveryRequestId::parse(id).unwrap(), copy(&ready.proof) ) @@ -409,8 +409,16 @@ async fn native_delivery_refuses_backward_clock_expired_attempt_and_unbound_obse // Structural data is deliberately untrusted; these are not remote ACKs. for (reported_work, raw, ordinals) in [ (work, first.raw_json().to_owned(), vec![1]), - (first.work(), format!("{} ", first.raw_json()), vec![1]), - (first.work(), first.raw_json().to_owned(), vec![2]), + ( + first.work().private().unwrap(), + format!("{} ", first.raw_json()), + vec![1], + ), + ( + first.work().private().unwrap(), + first.raw_json().to_owned(), + vec![2], + ), ] { let attempt = DeliveryAttempt::from_store_report( reported_work, @@ -488,7 +496,7 @@ async fn native_observation_query_never_crosses_original_request_or_recipient() ready.binding.clone(), e.operation_id(), e.command_digest(), - key(), + radroots_protocol::plan::SigningTarget::BusinessSeal(key()), attempt.intent().request_id().clone(), copy(&ready.proof) ) diff --git a/crates/radroots/tests/support/receipt_delivery_faults.rs b/crates/radroots/tests/support/receipt_delivery_faults.rs @@ -418,9 +418,9 @@ async fn actual_observation_rollback_and_commit_uncertainty_preserve_retained_ou let observation = not_attempted(&attempt); let mut database = ready.fixture.database().await; if commit { - sqlx::raw_sql("CREATE TABLE observation_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER observation_commit_fault_trigger AFTER INSERT ON chat_delivery_observations BEGIN INSERT INTO observation_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TABLE observation_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER observation_commit_fault_trigger AFTER INSERT ON artifact_delivery_observations BEGIN INSERT INTO observation_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); } else { - sqlx::raw_sql("CREATE TRIGGER observation_insert_fault BEFORE INSERT ON chat_delivery_observations BEGIN SELECT RAISE(ABORT,'synthetic observation fault'); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TRIGGER observation_insert_fault BEFORE INSERT ON artifact_delivery_observations BEGIN SELECT RAISE(ABORT,'synthetic observation fault'); END").execute(&mut database).await.unwrap(); } database.close().await.unwrap(); let result = ready @@ -446,7 +446,7 @@ async fn actual_observation_rollback_and_commit_uncertainty_preserve_retained_ou .await .unwrap(); } - let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM chat_delivery_attempts),(SELECT count(*) FROM chat_delivery_observations),(SELECT count(*) FROM chat_messages)").fetch_one(&mut database).await.unwrap(); + let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM artifact_delivery_attempts),(SELECT count(*) FROM artifact_delivery_observations),(SELECT count(*) FROM chat_messages)").fetch_one(&mut database).await.unwrap(); assert_eq!(counts, (1, 0, 1)); database.close().await.unwrap(); let reopened = ready.fixture.reopen(ready.input.clone()).await; @@ -497,13 +497,13 @@ async fn corrupted_delivery_ciphertext_and_oversized_observation_refuse_the_comp ); let mut database = ready.fixture.database().await; let original: Vec<u8> = - sqlx::query_scalar("SELECT protected FROM chat_delivery_parts WHERE part=1") + sqlx::query_scalar("SELECT protected FROM artifact_delivery_parts WHERE part=1") .fetch_one(&mut database) .await .unwrap(); let mut wrong = original.clone(); wrong[0] ^= 1; - sqlx::query("UPDATE chat_delivery_parts SET protected=? WHERE part=1") + sqlx::query("UPDATE artifact_delivery_parts SET protected=? WHERE part=1") .bind(wrong) .execute(&mut database) .await @@ -521,20 +521,21 @@ async fn corrupted_delivery_ciphertext_and_oversized_observation_refuse_the_comp .await .is_err() ); - sqlx::query("UPDATE chat_delivery_parts SET protected=? WHERE part=1") + sqlx::query("UPDATE artifact_delivery_parts SET protected=? WHERE part=1") .bind(original) .execute(&mut database) .await .unwrap(); - let original: Vec<u8> = sqlx::query_scalar("SELECT protected FROM chat_delivery_observations") - .fetch_one(&mut database) - .await - .unwrap(); + let original: Vec<u8> = + sqlx::query_scalar("SELECT protected FROM artifact_delivery_observations") + .fetch_one(&mut database) + .await + .unwrap(); sqlx::query("PRAGMA ignore_check_constraints=ON") .execute(&mut database) .await .unwrap(); - sqlx::query("UPDATE chat_delivery_observations SET protected=zeroblob(262145)") + sqlx::query("UPDATE artifact_delivery_observations SET protected=zeroblob(262145)") .execute(&mut database) .await .unwrap(); @@ -550,7 +551,7 @@ async fn corrupted_delivery_ciphertext_and_oversized_observation_refuse_the_comp .await .is_err() ); - sqlx::query("UPDATE chat_delivery_observations SET protected=?") + sqlx::query("UPDATE artifact_delivery_observations SET protected=?") .bind(original) .execute(&mut database) .await diff --git a/crates/radroots/tests/support/receipt_installation.rs b/crates/radroots/tests/support/receipt_installation.rs @@ -487,7 +487,7 @@ async fn predecessor_schema_five_retains_actual_claims_and_obtained_bytes_withou store.close().await.unwrap(); let mut database = fixture.database().await; sqlx::raw_sql( - "DROP TABLE public_publication_work; DROP TABLE listing_installations; DROP TABLE listing_creations; DROP TABLE chat_delivery_observations; DROP TABLE chat_delivery_parts; DROP TABLE chat_delivery_attempts; DROP TABLE chat_publication_work; DROP TABLE chat_messages; PRAGMA user_version=5", + "DROP TABLE public_publication_work; DROP TABLE listing_installations; DROP TABLE listing_creations; DROP TABLE artifact_delivery_observations; DROP TABLE artifact_delivery_parts; DROP TABLE artifact_delivery_attempts; DROP TABLE chat_publication_work; DROP TABLE chat_messages; PRAGMA user_version=5", ) .execute(&mut database) .await diff --git a/crates/radroots/tests/support/receipt_public_delivery.rs b/crates/radroots/tests/support/receipt_public_delivery.rs @@ -0,0 +1,752 @@ +//! Actual native public D over the existing journal and qualified Nostr sink. +use super::*; +use futures::{SinkExt, StreamExt}; +use nostr::JsonUtil; +use radroots_nostr::{ + key::parse_secret_key, + signing::{LocalSigner, OsNonceSource}, +}; +use radroots_protocol::{listing::PublicSigningPlan, plan::SigningReplay}; +use radroots_signing::{ + issuance::{OutcomeKind, SigningIntent}, + provider::{ParticipantProvider, ProviderCall}, + request::CancellationSignal, +}; +use radroots_storage::command::{ + ArtifactEvidence, ClaimAttemptOutcome, ClaimAttemptRequest, DeliveryAttempt, + DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryIntent, DeliveryObservation, + DeliveryObservationKind, DeliveryObservationOutcome, EvidenceCaptureOutcome, + InstallationOutcome, InstallationRequest, PlanBindingOutcome, PublicPublicationWork, + PublicationArtifact, SigningTarget, +}; +use radroots_transport::{ + EventSink, TargetSet, + policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, +}; +use radroots_transport_nostr::{ + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, +}; +use std::{ + num::NonZeroU64, + time::{SystemTime, UNIX_EPOCH}, +}; +use tokio::net::TcpListener; +use tokio_tungstenite::{accept_async, tungstenite::Message}; +fn now_ms() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_millis() + .try_into() + .unwrap() +} +fn signer_now() -> Result<u64, radroots_signing::Error> { + Ok(now_ms()) +} +struct Ready { + fixture: Fixture, + store: Arc<NativeWorkspace>, + input: AttachmentInput, + proof: AttachmentProof, + binding: WorkspaceBinding, + work: PublicPublicationWork, + raw: String, + config: Config, +} +impl Ready { + async fn new(urls: &[String], id: u8) -> Self { + let fixture = Fixture::new(); + let time = now_ms() / 1000; + fixture.clock.now.store(time, Ordering::SeqCst); + let (store, input, proof) = NativeWorkspace::initialize_local_outbox( + &fixture.path, + LocalOutboxConfig::seller( + key(), + key(), + "public-delivery", + UnixSeconds::new(time + 600).unwrap(), + ) + .unwrap(), + fixture.crypto(), + fixture.clock.clone(), + ) + .await + .unwrap(); + let binding = store.authenticate(input.clone(), &proof).await.unwrap(); + let store = Arc::new(store); + let context = CommandContextData::new( + OperationId::from_bytes([id; 32]), + binding.actor(), + input.workspace_id(), + input.authority(), + input.route_digest(), + None, + None, + UnixSeconds::new(time + 120).unwrap(), + None, + ) + .unwrap(); + let wire = json!({"type":"listing.publish","context":context,"input":{"id":format!("{id:02x}").repeat(16),"title":"Native public delivery","summary":"Quote required","description_markdown":"Public terms","published_at":time.to_string(),"profile":{"profile":"radroots.listing","version":1,"state":"active","product":{"name":"Carrots","description":"x".repeat(4096),"producer":null,"origin_summary":null},"default_option":"02".repeat(32),"options":[{"id":"02".repeat(32),"label":"Bunch","unit":{"type":"package","label":"bunch","contents":{"type":"unspecified"}},"increment":"1","minimum":"1","price":{"type":"quote_required"},"supply":{"type":"available","amount":"10"},"lead_seconds":"0"}],"fulfillment":{"modes":["pickup"],"area":"Example","lead_seconds":"0"},"authority":null,"media":[]}}}); + let prepared = committed( + store + .admit_command_and_hold( + AdmissionRequest::from_protected_wire( + binding.clone(), + &serde_json::to_vec(&wire).unwrap(), + ) + .unwrap(), + copy(&proof), + ) + .await + .unwrap(), + ); + let plan = PublicSigningPlan::capture( + prepared.request().command().listing().unwrap(), + UnixSeconds::new(time).unwrap(), + urls, + SigningReplay::NonReplayable, + ) + .unwrap(); + let digest = *plan.digest(); + assert!( + plan.event() + .fields() + .tags + .iter() + .any(|tag| tag.iter().any(|field| field.len() > 4096)) + ); + let PlanBindingOutcome::Committed(_) = store + .bind_signing_intents(binding.clone(), plan.into(), copy(&proof)) + .await + .unwrap() + else { + panic!("actual T1 commit") + }; + let ClaimAttemptOutcome::Claimed(attempt) = store + .claim_attempt( + ClaimAttemptRequest::for_artifact( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + digest, + SigningTarget::PublicEvent, + ), + copy(&proof), + ) + .await + .unwrap() + else { + panic!("actual first claim") + }; + let signer = LocalSigner::with_clock( + parse_secret_key("0000000000000000000000000000000000000000000000000000000000000001") + .unwrap(), + signer_now, + ) + .unwrap() + .with_nonce_source(Arc::new(OsNonceSource)); + let intent = SigningIntent::from_plan( + attempt.bound_plan().plan(), + SigningTarget::PublicEvent, + ProviderCall::new(key(), attempt.deadline_unix_ms(), CancellationSignal::new()), + ) + .unwrap(); + let (_, outcome) = signer.sign_exact(intent).await.into_parts(); + let OutcomeKind::Obtained(artifact) = outcome else { + panic!("actual public signature") + }; + let evidence = artifact.with_json(|raw| { + nostr::Event::from_json(raw).unwrap().verify().unwrap(); + ArtifactEvidence::verify(&attempt, raw, artifact.observed_at_unix_ms()).unwrap() + }); + let raw = evidence.raw_json().to_owned(); + assert!(matches!( + store + .capture_evidence(input.clone(), &proof, &evidence) + .await + .unwrap(), + EvidenceCaptureOutcome::Committed(_) + )); + assert!(matches!( + store + .install_transition_and_outbox( + InstallationRequest::new( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + digest + ), + copy(&proof) + ) + .await + .unwrap(), + InstallationOutcome::ListingCommitted(_) + )); + let snapshot = store + .operation_snapshot( + binding.clone(), + prepared.identity().operation_id(), + None, + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + let work = snapshot.public_publications()[0]; + let config = Config::from_profile( + RelayProfile::explicit( + RelayProfileKind::Simulator, + urls.iter().map(|url| { + RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap() + }), + ) + .unwrap(), + ) + .with_timeouts(1000, 1000, 500) + .unwrap(); + Self { + fixture, + store, + input, + proof, + binding, + work, + raw, + config, + } + } + fn targets(&self) -> TargetSet { + TargetSet::new( + self.config + .relays() + .iter() + .map(|v| v.to_target().unwrap()) + .collect(), + ) + .unwrap() + } + fn request(&self, id: u8) -> DeliveryAttemptRequest { + let now = self.fixture.clock.now().unwrap().get() * 1000; + DeliveryAttemptRequest::new( + self.binding.clone(), + self.work, + DeliveryIntent::public( + &format!("{id:02x}").repeat(32), + self.work.evidence().event_id(), + &self.targets(), + &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + NonZeroU64::new(now + 60_000).unwrap(), + ) + .unwrap(), + ) + .unwrap() + } + async fn retain(&self, id: u8) -> DeliveryAttempt { + match self + .store + .prepare_delivery_attempt(self.request(id), copy(&self.proof), None) + .await + .unwrap() + { + DeliveryAttemptOutcome::Claimed(v) => *v, + _ => panic!("actual fresh public D claim"), + } + } + async fn snapshot( + &self, + store: &NativeWorkspace, + ) -> radroots_storage::command::OperationSnapshot { + store + .operation_snapshot( + self.binding.clone(), + self.work.evidence().operation_id(), + Some(self.work.evidence().command_digest()), + copy(&self.proof), + ) + .await + .unwrap() + .unwrap() + } + async fn query( + &self, + store: &NativeWorkspace, + id: &radroots_transport::sink::DeliveryRequestId, + ) -> Option<DeliveryAttempt> { + store + .delivery_attempt( + self.binding.clone(), + self.work.evidence().operation_id(), + self.work.evidence().command_digest(), + SigningTarget::PublicEvent, + id.clone(), + copy(&self.proof), + ) + .await + .unwrap() + } +} +#[tokio::test] +async fn public_d_retains_original_before_actual_loopback_and_reopens_independent_ack() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let ready = Ready::new(&[format!("ws://{}", listener.local_addr().unwrap())], 180).await; + let attempt = ready.retain(1).await; + assert_eq!(attempt.raw_json(), ready.raw); + assert_eq!(attempt.work(), PublicationArtifact::Public(ready.work)); + assert_eq!(attempt.work().recipient(), None); + assert_eq!( + attempt.intent().event_id(), + ready.work.evidence().event_id() + ); + let snapshot = ready.snapshot(&ready.store).await; + let checkpoint = snapshot.checkpoint_digest(); + assert!(snapshot.installed_message().is_none()); + assert!(snapshot.publications().is_empty()); + assert_eq!(snapshot.public_publications(), &[ready.work]); + assert_eq!(snapshot.delivery_attempts().len(), 1); + assert!(!snapshot.publication_accepted(ready.work).unwrap()); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) + .await + .unwrap(), + DeliveryAttemptOutcome::Retained(_) + )); + let expected = format!("[\"EVENT\",{}]", ready.raw); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let raw = tokio::time::timeout(Duration::from_secs(5), async { + loop { + if let Message::Text(raw) = socket.next().await.unwrap().unwrap() { + break raw; + } + } + }) + .await + .unwrap(); + assert_eq!(raw.as_str(), expected); + let frame: serde_json::Value = serde_json::from_str(&raw).unwrap(); + let event = nostr::Event::from_json(frame[1].to_string()).unwrap(); + event.verify().unwrap(); + assert_eq!(event.kind.as_u16(), 30402); + socket + .send(Message::Text( + json!(["OK", "ff".repeat(32), true, ""]).to_string().into(), + )) + .await + .unwrap(); + socket + .send(Message::Text( + json!(["OK", frame[1]["id"], true, ""]).to_string().into(), + )) + .await + .unwrap(); + }); + let transport = radroots_transport_nostr_native::create_transport(ready.config.clone()); + let request = attempt.transport_request().unwrap(); + let selected = attempt.intent().selected_target_set().unwrap(); + let receipt = transport + .deliver_selected(request.clone(), selected) + .await + .unwrap(); + receipt.validate_for_request(&request).unwrap(); + assert!(receipt.is_satisfied(&request).unwrap()); + server.await.unwrap(); + let observation = DeliveryObservation::from_receipt( + &attempt, + &receipt, + request.target_set().targets()[0].fingerprint(), + None, + ) + .unwrap(); + assert_eq!(observation.kind(), DeliveryObservationKind::Accepted); + let DeliveryObservationOutcome::Committed(first) = ready + .store + .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation) + .await + .unwrap() + else { + panic!("actual durable ACK") + }; + let complete = ready.snapshot(&ready.store).await; + assert_ne!(complete.checkpoint_digest(), checkpoint); + assert!(complete.publication_accepted(ready.work).unwrap()); + assert_eq!( + complete.listing_installation(), + snapshot.listing_installation() + ); + transport.shutdown().await; + ready.store.close().await.unwrap(); + let reopened = ready.fixture.reopen(ready.input.clone()).await; + let retained = ready + .query(&reopened, attempt.intent().request_id()) + .await + .unwrap(); + assert_eq!(retained.raw_json(), ready.raw); + assert_eq!(retained.transaction_id(), attempt.transaction_id()); + let observations = reopened + .delivery_observations( + ready.binding.clone(), + ready.work.evidence().operation_id(), + ready.work.evidence().command_digest(), + SigningTarget::PublicEvent, + attempt.intent().request_id().clone(), + copy(&ready.proof), + ) + .await + .unwrap(); + assert_eq!(observations, vec![first]); + assert!( + ready + .snapshot(&reopened) + .await + .publication_accepted(ready.work) + .unwrap() + ); + reopened.close().await.unwrap(); +} +#[tokio::test] +async fn public_d_requires_original_targets_role_and_current_proof_before_any_claim() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 181).await; + assert!( + DeliveryAttemptRequest::new( + ready.binding.clone(), + ready.work, + DeliveryIntent::new( + &"11".repeat(32), + ready.work.evidence().event_id(), + &ready.targets(), + &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + NonZeroU64::new(now_ms() + 60_000).unwrap() + ) + .unwrap() + ) + .is_err() + ); + assert!(matches!( + ready + .store + .prepare_delivery_attempt( + ready.request(1), + AttachmentProof::from_protected_input(&[0; 32]).unwrap(), + None + ) + .await, + Err(OperationError::Workspace(WorkspaceError::Unauthorized)) + )); + let other = TargetSet::new(vec![ + radroots_transport::Target::nostr_relay("ws://127.0.0.1:10").unwrap(), + ]) + .unwrap(); + let request = DeliveryAttemptRequest::new( + ready.binding.clone(), + ready.work, + DeliveryIntent::public( + &"11".repeat(32), + ready.work.evidence().event_id(), + &other, + &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + NonZeroU64::new(now_ms() + 60_000).unwrap(), + ) + .unwrap(), + ) + .unwrap(); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(request, copy(&ready.proof), None) + .await, + Err(OperationError::UnverifiedApproval) + )); + assert!( + ready + .snapshot(&ready.store) + .await + .delivery_attempts() + .is_empty() + ); + ready.store.close().await.unwrap(); +} +#[tokio::test] +async fn public_retries_reuse_original_after_first_issue_expiry_and_spend_twelve_endpoint_slots() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 182).await; + ready.fixture.clock.now.fetch_add(121, Ordering::SeqCst); + for id in 1..=12 { + let attempt = ready.retain(id).await; + assert_eq!(attempt.raw_json(), ready.raw); + assert_eq!(attempt.target_ordinals(), &[id]); + } + assert!(matches!( + ready + .store + .prepare_delivery_attempt(ready.request(13), copy(&ready.proof), None) + .await, + Err(OperationError::DeliveryAttemptLimit) + )); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) + .await + .unwrap(), + DeliveryAttemptOutcome::Retained(_) + )); + let state = ready.snapshot(&ready.store).await; + assert_eq!(state.delivery_attempts().len(), 12); + assert!(state.delivery_observations().is_empty()); + assert!(!state.publication_accepted(ready.work).unwrap()); + ready.store.close().await.unwrap(); + let reopened = ready.fixture.reopen(ready.input.clone()).await; + let state = ready.snapshot(&reopened).await; + assert_eq!(state.delivery_attempts().len(), 12); + reopened.close().await.unwrap(); +} +#[tokio::test] +async fn public_d_part_insert_failure_rolls_back_without_losing_installed_revision() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 183).await; + let mut db = ready.fixture.database().await; + sqlx::raw_sql("CREATE TRIGGER fail_public_d BEFORE INSERT ON artifact_delivery_parts BEGIN SELECT RAISE(ABORT,'isolated fixture'); END").execute(&mut db).await.unwrap(); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) + .await, + Err(OperationError::StorageFailure) + )); + let state = ready.snapshot(&ready.store).await; + assert!(state.listing_installation().is_some()); + assert!(state.delivery_attempts().is_empty()); + sqlx::query("DROP TRIGGER fail_public_d") + .execute(&mut db) + .await + .unwrap(); + db.close().await.unwrap(); + let retained = ready.retain(1).await; + assert_eq!(retained.raw_json(), ready.raw); + ready.store.close().await.unwrap(); +} +#[tokio::test] +async fn lost_public_d_observer_never_turns_reopen_into_dispatch_permission() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 184).await; + let (arrived, resume) = ready.fixture.clock.arm(1); + let mut pending = + ready + .store + .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None); + assert!(futures::poll!(pending.as_mut()).is_pending()); + reached(arrived).await; + drop(pending); + resume.send(()).unwrap(); + ready.store.close().await.unwrap(); + let reopened = ready.fixture.reopen(ready.input.clone()).await; + assert!(matches!( + reopened + .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) + .await + .unwrap(), + DeliveryAttemptOutcome::Retained(_) + )); + assert_eq!(ready.snapshot(&reopened).await.delivery_attempts().len(), 1); + reopened.close().await.unwrap(); +} + +#[tokio::test] +async fn actual_public_rejection_disconnect_and_missing_matching_ack_remain_independent() { + for (mode, expected) in [ + (0, DeliveryObservationKind::Rejected), + (1, DeliveryObservationKind::Disconnected), + (2, DeliveryObservationKind::TimedOut), + ] { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let ready = Ready::new( + &[format!("ws://{}", listener.local_addr().unwrap())], + 185 + mode, + ) + .await; + let deadline = NonZeroU64::new(now_ms() + 2_000).unwrap(); + let request = DeliveryAttemptRequest::new( + ready.binding.clone(), + ready.work, + DeliveryIntent::public( + &format!("{mode:02x}").repeat(32), + ready.work.evidence().event_id(), + &ready.targets(), + &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + deadline, + ) + .unwrap(), + ) + .unwrap(); + let DeliveryAttemptOutcome::Claimed(attempt) = ready + .store + .prepare_delivery_attempt(request, copy(&ready.proof), None) + .await + .unwrap() + else { + panic!("actual public D") + }; + let (release, held) = tokio::sync::oneshot::channel::<()>(); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let raw = tokio::time::timeout(Duration::from_secs(5), async { + loop { + if let Message::Text(raw) = socket.next().await.unwrap().unwrap() { + break raw; + } + } + }) + .await + .unwrap(); + let event: serde_json::Value = serde_json::from_str(&raw).unwrap(); + match mode { + 0 => socket + .send(Message::Text( + json!(["OK", event[1]["id"], false, "blocked: denied"]) + .to_string() + .into(), + )) + .await + .unwrap(), + 1 => { + socket.close(None).await.unwrap(); + } + _ => socket + .send(Message::Text( + json!(["OK", "ff".repeat(32), true, ""]).to_string().into(), + )) + .await + .unwrap(), + } + let _ = held.await; + }); + let transport = radroots_transport_nostr_native::create_transport(ready.config.clone()); + let request = attempt.transport_request().unwrap(); + let target = request.target_set().targets()[0].fingerprint(); + let result = transport + .deliver_selected( + request.clone(), + attempt.intent().selected_target_set().unwrap(), + ) + .await; + let observation = match result { + Ok(receipt) => { + assert!(!receipt.is_satisfied(&request).unwrap()); + DeliveryObservation::from_receipt(&attempt, &receipt, target, None).unwrap() + } + Err(failure) => { + DeliveryObservation::from_failure(&attempt, &failure, target, None).unwrap() + } + }; + assert_eq!(observation.kind(), expected); + // Already obtained original target evidence remains capturable while a + // fresh clock/access check would refuse another operation. + ready.fixture.clock.now.store(0, Ordering::SeqCst); + assert!(matches!( + ready + .store + .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation) + .await + .unwrap(), + DeliveryObservationOutcome::Committed(_) + )); + ready + .fixture + .clock + .now + .store(now_ms() / 1000, Ordering::SeqCst); + assert!( + !ready + .snapshot(&ready.store) + .await + .publication_accepted(ready.work) + .unwrap() + ); + let _ = release.send(()); + server.await.unwrap(); + transport.shutdown().await; + ready.store.close().await.unwrap(); + } +} +#[tokio::test] +async fn unknown_public_d_commit_requires_safe_reopen_and_never_reports_a_dispatch_right() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 188).await; + let mut db = ready.fixture.database().await; + sqlx::raw_sql("CREATE TABLE deferred_d_fault(value INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER fail_public_d_commit AFTER INSERT ON artifact_delivery_attempts BEGIN INSERT INTO deferred_d_fault VALUES(2); END").execute(&mut db).await.unwrap(); + let request = ready.request(1); + let id = request.intent().request_id().clone(); + let DeliveryAttemptOutcome::Unknown { operation, attempt } = ready + .store + .prepare_delivery_attempt(request, copy(&ready.proof), None) + .await + .unwrap() + else { + panic!("actual failed COMMIT must be unknown") + }; + assert_eq!(attempt, id); + assert_eq!( + operation.operation_id(), + ready.work.evidence().operation_id() + ); + assert!(operation.transaction_id().is_some()); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None) + .await, + Err(OperationError::RecoveryRequired) + )); + ready.store.close().await.unwrap(); + sqlx::raw_sql("DROP TRIGGER fail_public_d_commit; DROP TABLE deferred_d_fault") + .execute(&mut db) + .await + .unwrap(); + db.close().await.unwrap(); + let reopened = ready.fixture.reopen(ready.input.clone()).await; + assert!(ready.query(&reopened, &id).await.is_none()); + let state = ready.snapshot(&reopened).await; + assert!(state.delivery_attempts().is_empty()); + assert!(state.listing_installation().is_some()); + assert!(!state.publication_accepted(ready.work).unwrap()); + reopened.close().await.unwrap(); +} +#[tokio::test] +async fn current_public_scope_and_original_policy_cannot_be_replaced_by_a_new_attempt() { + let ready = Ready::new(&["ws://127.0.0.1:9".into()], 189).await; + let original = ready.retain(1).await; + let changed = DeliveryAttemptRequest::new( + ready.binding.clone(), + ready.work, + DeliveryIntent::public( + &"02".repeat(32), + ready.work.evidence().event_id(), + &ready.targets(), + &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::any()), + NonZeroU64::new(now_ms() + 60_000).unwrap(), + ) + .unwrap(), + ) + .unwrap(); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(changed, copy(&ready.proof), None) + .await, + Err(OperationError::IdempotencyConflict) + )); + ready + .store + .revoke(ready.input.clone(), &ready.proof) + .await + .unwrap(); + assert!(matches!( + ready + .store + .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None) + .await, + Err(OperationError::Workspace(WorkspaceError::GrantRevoked)) + )); + assert_eq!(original.raw_json(), ready.raw); + ready.store.close().await.unwrap(); +} diff --git a/crates/radroots/tests/support/receipt_workflow_faults.rs b/crates/radroots/tests/support/receipt_workflow_faults.rs @@ -365,7 +365,7 @@ async fn explicit_delivery_retry_after_first_issue_expiry_preserves_original_byt ready.scope.binding().clone(), OperationId::from_bytes([203; 32]), first.command_digest(), - attempt.work().recipient(), + attempt.work().target(), attempt.intent().request_id().clone(), copy(&ready.proof), ) @@ -418,7 +418,9 @@ async fn explicit_delivery_retry_after_first_issue_expiry_preserves_original_byt let attempts: Vec<_> = snapshot .delivery_attempts() .iter() - .filter(|attempt| attempt.work() == *work) + .filter(|attempt| { + attempt.work() == radroots_storage::command::PublicationArtifact::Private(*work) + }) .collect(); assert_eq!( attempts[0].intent().publication_policy_digest(), diff --git a/crates/storage/src/command.rs b/crates/storage/src/command.rs @@ -21,6 +21,8 @@ mod dm_source; mod installation; mod issuance; mod observation; +mod publication; +pub use publication::PublicationArtifact; mod snapshot; pub use delivery::{ DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryIntent, @@ -344,11 +346,11 @@ pub trait OperationJournal: WorkspaceStore { binding: WorkspaceBinding, operation: radroots_domain::OperationId, digest: radroots_domain::CommandDigest, - recipient: radroots_domain::PublicKey, + target: SigningTarget, request: radroots_transport::sink::DeliveryRequestId, proof: AttachmentProof, ) -> BoxFuture<'_, Result<Vec<DeliveryObservation>, OperationError>>; - /// Atomically retains exact outer bytes and every selected target intent + /// Atomically retains exact signed payload bytes and every selected target intent /// before transport. A fresh actual commit may be dispatched once by its /// qualified owner. Restored or unknown claims never permit replay. fn prepare_delivery_attempt<'a>( @@ -364,7 +366,7 @@ pub trait OperationJournal: WorkspaceStore { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: radroots_domain::PublicKey, + target: SigningTarget, request: radroots_transport::sink::DeliveryRequestId, proof: AttachmentProof, ) -> BoxFuture<'_, Result<Option<DeliveryAttempt>, OperationError>>; @@ -377,7 +379,7 @@ pub trait OperationJournal: WorkspaceStore { request: InstallationRequest, proof: AttachmentProof, ) -> BoxFuture<'_, Result<InstallationOutcome, OperationError>>; - /// Queries one coherent original preparation/plan/per-recipient evidence + /// Queries one coherent original preparation/plan/per-artifact evidence /// graph under current access. Reported absence grants no safe reissue. fn operation_snapshot( &self, diff --git a/crates/storage/src/command/delivery.rs b/crates/storage/src/command/delivery.rs @@ -1,8 +1,8 @@ -//! Bounded private delivery data. Constructors authenticate carriers only; +//! Bounded public/private delivery data. Constructors authenticate artifacts only; //! actual protected work, containment, authorization and dispatch belong to //! qualified store/execution owners, never to a report or enum variant. -use super::{CommitAttempt, OperationError, PublicationWork}; +use super::{CommitAttempt, OperationError, PublicationArtifact, PublicationWork, SigningTarget}; use crate::workspace::WorkspaceBinding; use core::{fmt, num::NonZeroU64}; use radroots_domain::{EnvelopeEventId, PublicKey, TransactionId, UnixSeconds}; @@ -11,6 +11,7 @@ use radroots_event::{ wire::{EventWireLimits, Nip01EventWire}, }; use radroots_event_codec::verify::{self, Nip01SignatureVerifier, RawEvent}; +use radroots_protocol::intent::ArtifactRole; use radroots_transport::{ TargetSet, TransportId, policy::{SatisfactionClass, SatisfactionPolicy}, @@ -51,6 +52,42 @@ fn outer(raw: &str, recipient: PublicKey) -> Result<SignedEvent, OperationError> Ok(event) } +fn public_event(raw: &str, work: PublicationArtifact) -> Result<SignedEvent, OperationError> { + if work.target() != SigningTarget::PublicEvent || raw.len() > SIGNED_MAX_BYTES { + return Err(OperationError::InvalidEvidence); + } + let limits = EventWireLimits { + max_raw_json_bytes: SIGNED_MAX_BYTES, + max_content_bytes: SIGNED_MAX_BYTES, + max_tag_count: radroots_protocol::listing::LISTING_TAG_MAX_COUNT, + max_total_tag_elements: radroots_protocol::listing::LISTING_TAG_TOTAL_ELEMENT_MAX_COUNT, + max_tag_element_bytes: SIGNED_MAX_BYTES, + max_total_tag_bytes: SIGNED_MAX_BYTES, + max_extra_fields: 0, + max_total_extra_json_bytes: 0, + }; + let wire = Nip01EventWire::parse_json_exact_with_limits(raw, limits) + .map_err(|_| OperationError::InvalidEvidence)?; + if wire.kind != radroots_protocol::listing::LISTING_KIND + || wire.id != work.evidence().event_id().to_string() + || <[u8; 32]>::from(Sha256::digest(raw.as_bytes())) != *work.evidence().digest() + { + return Err(OperationError::InvalidEvidence); + } + let event = SignedEvent::from_wire_verified_id_with_limits(wire, raw, limits) + .map_err(|_| OperationError::InvalidEvidence)?; + let id = verify::id(RawEvent::new(event.envelope().clone())) + .map_err(|_| OperationError::InvalidEvidence)?; + verify::signature(id, &Nip01SignatureVerifier).map_err(|_| OperationError::InvalidEvidence)?; + Ok(event) +} +fn payload(raw: &str, work: PublicationArtifact) -> Result<SignedEvent, OperationError> { + match work { + PublicationArtifact::Private(v) => outer(raw, v.recipient()), + PublicationArtifact::Public(_) => public_event(raw, work), + } +} + /// One obtained outer awaiting protected native verification and retention. /// The key is temporary wrapping material, not participant custody. A matching /// signature proves neither original-seal containment nor an actual store link. @@ -136,6 +173,7 @@ impl fmt::Debug for EnvelopeCandidate { /// policy nor target construction proves an original route approval or lease. #[derive(Clone, Eq, PartialEq)] pub struct DeliveryIntent { + role: ArtifactRole, request: DeliveryRequestId, event: EnvelopeEventId, targets: TargetSet, @@ -156,6 +194,41 @@ impl DeliveryIntent { policy: &SatisfactionPolicy, deadline: NonZeroU64, ) -> Result<Self, OperationError> { + Self::capture( + ArtifactRole::GiftWrap, + request_id, + event, + targets, + policy, + deadline, + ) + } + /// Direct public EVENT intent, without a private carrier or participant. + /// Actual original work/targets and dispatch rights remain backend-owned. + pub fn public( + request_id: &str, + event: EnvelopeEventId, + targets: &TargetSet, + policy: &SatisfactionPolicy, + deadline: NonZeroU64, + ) -> Result<Self, OperationError> { + Self::capture( + ArtifactRole::PublicEvent, + request_id, + event, + targets, + policy, + deadline, + ) + } + fn capture( + role: ArtifactRole, + request_id: &str, + event: EnvelopeEventId, + targets: &TargetSet, + policy: &SatisfactionPolicy, + deadline: NonZeroU64, + ) -> Result<Self, OperationError> { if request_id.len() != 64 || !request_id .bytes() @@ -185,7 +258,11 @@ impl DeliveryIntent { let request = DeliveryRequestId::parse(request_id).map_err(|_| OperationError::InvalidCommand)?; let mut hash = Sha256::new(); - hash.update(b"radroots.private.delivery.publication_policy.v1\0"); + hash.update(if role == ArtifactRole::PublicEvent { + b"radroots.public.delivery.publication_policy.v1\0".as_slice() + } else { + b"radroots.private.delivery.publication_policy.v1\0".as_slice() + }); hash.update((targets.len() as u16).to_be_bytes()); for target in targets.targets() { hash.update(target.fingerprint().as_str().as_bytes()); @@ -208,6 +285,7 @@ impl DeliveryIntent { return Err(OperationError::InvalidCommand); } let mut value = Self { + role, request, event, targets: targets.clone(), @@ -226,7 +304,11 @@ impl DeliveryIntent { } fn refresh_digest(&mut self) { let mut hash = Sha256::new(); - hash.update(b"radroots.private.delivery.intent.v1\0"); + hash.update(if self.role == ArtifactRole::PublicEvent { + b"radroots.public.delivery.intent.v1\0".as_slice() + } else { + b"radroots.private.delivery.intent.v1\0".as_slice() + }); hash.update(self.request.as_str().as_bytes()); hash.update(self.event.as_bytes()); hash.update(self.publication_policy); @@ -259,6 +341,10 @@ impl DeliveryIntent { self.refresh_digest(); Ok(self) } + /// Actual transport artifact family; the private family is a gift wrap. + pub const fn role(&self) -> ArtifactRole { + self.role + } /// Complete original publication criterion, excluding attempt ID, envelope /// selection and per-attempt deadline. The native owner freezes this /// criterion for the original recipient work. @@ -286,7 +372,7 @@ impl DeliveryIntent { pub const fn request_id(&self) -> &DeliveryRequestId { &self.request } - /// Actual selected outer identity. + /// Actual selected public EVENT or private outer identity. pub const fn event_id(&self) -> EnvelopeEventId { self.event } @@ -317,7 +403,7 @@ impl fmt::Debug for DeliveryIntent { /// Selects actual retained publication work for one potential transport attempt. pub struct DeliveryAttemptRequest { binding: WorkspaceBinding, - work: PublicationWork, + work: PublicationArtifact, intent: DeliveryIntent, } impl DeliveryAttemptRequest { @@ -325,10 +411,17 @@ impl DeliveryAttemptRequest { /// original complete graph, current grant and exact selected routes. pub fn new( binding: WorkspaceBinding, - work: PublicationWork, + work: impl Into<PublicationArtifact>, intent: DeliveryIntent, ) -> Result<Self, OperationError> { - if binding.input().workspace_id() != work.evidence().workspace_id() { + let work = work.into(); + if binding.input().workspace_id() != work.evidence().workspace_id() + || !matches!( + (work, intent.role()), + (PublicationArtifact::Private(_), ArtifactRole::GiftWrap) + | (PublicationArtifact::Public(_), ArtifactRole::PublicEvent) + ) + { return Err(OperationError::InvalidCommand); } Ok(Self { @@ -342,7 +435,7 @@ impl DeliveryAttemptRequest { &self.binding } /// Immutable reported work; native capture compares its actual protected row. - pub const fn work(&self) -> PublicationWork { + pub const fn work(&self) -> PublicationArtifact { self.work } /// Exact requested transport intent. @@ -364,7 +457,7 @@ impl fmt::Debug for DeliveryAttemptRequest { /// Complete original attempt report and exact bytes. Constructing or querying /// this value never permits replay of a potential invocation. pub struct DeliveryAttempt { - work: PublicationWork, + work: PublicationArtifact, intent: DeliveryIntent, raw: Zeroizing<String>, digest: [u8; 32], @@ -376,14 +469,22 @@ impl DeliveryAttempt { /// Checks scoped data and carrier authenticity only. Native backends must /// independently verify original protected state and execute retention. pub fn from_store_report( - work: PublicationWork, + work: impl Into<PublicationArtifact>, intent: DeliveryIntent, raw: &str, transaction: TransactionId, retained_at: UnixSeconds, ordinals: Vec<u8>, ) -> Result<Self, OperationError> { - let event = outer(raw, work.recipient())?; + let work = work.into(); + if !matches!( + (work, intent.role()), + (PublicationArtifact::Private(_), ArtifactRole::GiftWrap) + | (PublicationArtifact::Public(_), ArtifactRole::PublicEvent) + ) { + return Err(OperationError::InvalidEvidence); + } + let event = payload(raw, work)?; if event.envelope().id().as_bytes() != intent.event_id().as_bytes() || retained_at < work.queued_at() || event.envelope().created_at_u64() > retained_at.get() @@ -407,14 +508,14 @@ impl DeliveryAttempt { }) } /// Original protected publication reference. - pub const fn work(&self) -> PublicationWork { + pub const fn work(&self) -> PublicationArtifact { self.work } /// Original complete transport intent. pub const fn intent(&self) -> &DeliveryIntent { &self.intent } - /// Exact originally retained outer representation. + /// Exact originally retained signed representation. pub fn raw_json(&self) -> &str { &self.raw } @@ -439,7 +540,7 @@ impl DeliveryAttempt { /// unselected endpoints have no retained invocation. This data conversion /// grants no dispatch permission or automatic retry. pub fn transport_request(&self) -> Result<DeliveryRequest, OperationError> { - let event = outer(self.raw_json(), self.work.recipient())?; + let event = payload(self.raw_json(), self.work)?; DeliveryRequest::new( self.intent.request_id().as_str(), DeliveryPayload::new(event), diff --git a/crates/storage/src/command/delivery_summary.rs b/crates/storage/src/command/delivery_summary.rs @@ -1,5 +1,5 @@ use super::{ - DeliveryAttempt, DeliveryIntent, DeliveryObservation, OperationError, PublicationWork, + DeliveryAttempt, DeliveryIntent, DeliveryObservation, OperationError, PublicationArtifact, }; use core::fmt; use radroots_domain::{TransactionId, UnixSeconds}; @@ -8,7 +8,7 @@ use radroots_domain::{TransactionId, UnixSeconds}; /// bytes. This data projection grants no dispatch permission or storage proof. #[derive(Clone, Eq, PartialEq)] pub struct DeliveryAttemptSummary { - work: PublicationWork, + work: PublicationArtifact, intent: DeliveryIntent, digest: [u8; 32], transaction: TransactionId, @@ -28,7 +28,7 @@ impl DeliveryAttemptSummary { } } /// Original protected publication linkage. - pub const fn work(&self) -> PublicationWork { + pub const fn work(&self) -> PublicationArtifact { self.work } /// Complete immutable original transport intent. diff --git a/crates/storage/src/command/observation.rs b/crates/storage/src/command/observation.rs @@ -1,6 +1,6 @@ //! Bounded observations of an already retained exact transport attempt. -use super::{DeliveryAttempt, OperationError, PublicationWork}; +use super::{DeliveryAttempt, OperationError, PublicationArtifact}; use core::{fmt, num::NonZeroU64}; use radroots_domain::EnvelopeEventId; use radroots_transport::{ @@ -45,7 +45,7 @@ impl DeliveryObservationKind { /// or storage. The native owner independently checks actual protected linkage. #[derive(Clone, Eq, PartialEq)] pub struct DeliveryObservation { - work: PublicationWork, + work: PublicationArtifact, request: DeliveryRequestId, event: EnvelopeEventId, envelope_digest: [u8; 32], @@ -150,7 +150,7 @@ impl DeliveryObservation { }) } /// Original publication scope, independently checked by the native owner. - pub const fn work(&self) -> PublicationWork { + pub const fn work(&self) -> PublicationArtifact { self.work } /// Full original potential invocation identity. diff --git a/crates/storage/src/command/publication.rs b/crates/storage/src/command/publication.rs @@ -0,0 +1,91 @@ +//! Exact publication scope. Values describe retained work; they do not grant +//! a writer lease, transport permission or proof of a committed row. +use super::{ + EvidenceReceipt, OperationError, PublicPublicationWork, PublicationWork, SigningTarget, +}; +use core::fmt; +use radroots_domain::{PublicKey, TransactionId, UnixSeconds}; + +/// One actual installed artifact's pending publication work. A public event has +/// no private participant or wrapping identity. +#[derive(Clone, Copy, Eq, PartialEq)] +pub enum PublicationArtifact { + /// Original private seal work, published through its verified outer carrier. + Private(PublicationWork), + /// Original public signed event, published directly without another signer. + Public(PublicPublicationWork), +} +impl PublicationArtifact { + /// Actual original captured artifact selection. + pub const fn target(self) -> SigningTarget { + self.evidence().target() + } + /// Actual private participant, absent for public work. + pub const fn recipient(self) -> Option<PublicKey> { + self.target().recipient() + } + /// Private-only projection; absence never becomes a synthetic participant. + pub fn private(self) -> Result<PublicationWork, OperationError> { + match self { + Self::Private(v) => Ok(v), + Self::Public(_) => Err(OperationError::UnsupportedOperation), + } + } + /// Public-only projection without a private carrier fallback. + pub fn public(self) -> Result<PublicPublicationWork, OperationError> { + match self { + Self::Public(v) => Ok(v), + Self::Private(_) => Err(OperationError::UnsupportedOperation), + } + } + /// Original installed business transaction, separate from transport. + pub const fn installation_transaction_id(self) -> TransactionId { + match self { + Self::Private(v) => v.installation_transaction_id(), + Self::Public(v) => v.installation_transaction_id(), + } + } + /// Original complete signing plan and its captured publication inputs. + pub const fn plan_digest(&self) -> &[u8; 32] { + match self { + Self::Private(v) => v.plan_digest(), + Self::Public(v) => v.plan_digest(), + } + } + /// Original exact obtained artifact reference. + pub const fn evidence(self) -> EvidenceReceipt { + match self { + Self::Private(v) => v.evidence(), + Self::Public(v) => v.evidence(), + } + } + /// Original pending-work retention transaction. + pub const fn transaction_id(self) -> TransactionId { + match self { + Self::Private(v) => v.transaction_id(), + Self::Public(v) => v.transaction_id(), + } + } + /// Original queued observation, never a renewed dispatch deadline. + pub const fn queued_at(self) -> UnixSeconds { + match self { + Self::Private(v) => v.queued_at(), + Self::Public(v) => v.queued_at(), + } + } +} +impl From<PublicationWork> for PublicationArtifact { + fn from(v: PublicationWork) -> Self { + Self::Private(v) + } +} +impl From<PublicPublicationWork> for PublicationArtifact { + fn from(v: PublicPublicationWork) -> Self { + Self::Public(v) + } +} +impl fmt::Debug for PublicationArtifact { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("PublicationArtifact(<redacted>)") + } +} diff --git a/crates/storage/src/command/snapshot.rs b/crates/storage/src/command/snapshot.rs @@ -3,7 +3,7 @@ use super::{ BoundSigningPlan, ChatInstallation, DeliveryAttemptSummary, DeliveryObservation, EvidenceReceipt, ListingInstallation, OperationError, PreparedOperation, PublicPublicationWork, - PublicationWork, SigningAttempt, + PublicationArtifact, PublicationWork, SigningAttempt, }; use core::fmt; use radroots_domain::{ @@ -628,7 +628,7 @@ impl OperationSnapshot { }); let mut keys = BTreeSet::new(); let mut transactions = BTreeSet::new(); - let mut counters = BTreeMap::<(PublicKey, &str), BTreeSet<u8>>::new(); + let mut counters = BTreeMap::<(Option<PublicKey>, &str), BTreeSet<u8>>::new(); let mut slots = 0usize; let mut policies = BTreeMap::new(); for attempt in &attempts { @@ -637,7 +637,7 @@ impl OperationSnapshot { .checked_add(attempt.intent().selection().len()) .filter(|n| *n <= 384) .ok_or(OperationError::RecoveryRequired)?; - if !self.publications.contains(&attempt.work()) + if !self.contains_publication(attempt.work()) || !keys.insert((recipient, attempt.intent().request_id().as_str())) || !transactions.insert(attempt.transaction_id()) || attempt.target_ordinals().len() != attempt.intent().selection().len() @@ -724,6 +724,12 @@ impl OperationSnapshot { self.observations = observations.into_boxed_slice(); Ok(self) } + fn contains_publication(&self, work: PublicationArtifact) -> bool { + match work { + PublicationArtifact::Private(v) => self.publications.contains(&v), + PublicationArtifact::Public(v) => self.public_publications.contains(&v), + } + } /// Original exact-envelope/target intent references, with no duplicated raw payload. pub fn delivery_attempts(&self) -> &[DeliveryAttemptSummary] { &self.deliveries @@ -735,8 +741,12 @@ impl OperationSnapshot { /// Evaluates the original full publication criterion across all exact /// attempts for this work. Retry selection never narrows the criterion; /// an earlier acceptance remains authoritative across later failures. - pub fn publication_accepted(&self, work: PublicationWork) -> Result<bool, OperationError> { - if !self.publications.contains(&work) { + pub fn publication_accepted( + &self, + work: impl Into<PublicationArtifact>, + ) -> Result<bool, OperationError> { + let work = work.into(); + if !self.contains_publication(work) { return Err(OperationError::InvalidEvidence); } let Some(original) = self diff --git a/crates/storage_indexeddb/src/workspace/delivery/observation_operations.rs b/crates/storage_indexeddb/src/workspace/delivery/observation_operations.rs @@ -4,7 +4,7 @@ use crate::workspace::{ journal::{self, OperationChange}, owned, }; -use radroots_domain::{CommandDigest, OperationId, PublicKey}; +use radroots_domain::{CommandDigest, OperationId}; use radroots_storage::{ command::{DeliveryObservation, DeliveryObservationOutcome, OperationError}, workspace::{AttachmentProof, WorkspaceBinding}, @@ -28,7 +28,7 @@ impl BrowserWorkspace { let result = owned(work, async move { let input = binding.input().clone(); let (grant, protected) = state.capture_retained(&input, &proof).await?; - let actual_work = supplied.work(); + let actual_work = supplied.work().private()?; let evidence = actual_work.evidence(); let operation = evidence.operation_id(); let view = state.read_view(operation).await?; @@ -54,7 +54,7 @@ impl BrowserWorkspace { &binding, )?; let attempt = facts.selected.ok_or(OperationError::InvalidEvidence)?; - if attempt.work() != actual_work { + if attempt.work().private()? != actual_work { return Err(OperationError::InvalidEvidence); } let checked = DeliveryObservation::from_store_report( @@ -66,7 +66,7 @@ impl BrowserWorkspace { return Err(OperationError::InvalidEvidence); } let existing = snapshot.delivery_observations().iter().find(|value| { - value.work() == actual_work + value.work().private().ok() == Some(actual_work) && value.request_id() == supplied.request_id() && value.target_receipt().target().fingerprint() == supplied.target_receipt().target().fingerprint() @@ -127,7 +127,7 @@ impl BrowserWorkspace { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: radroots_storage::command::SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> Result<Vec<DeliveryObservation>, OperationError> { @@ -138,6 +138,9 @@ impl BrowserWorkspace { let state = self.state.clone(); owned(work, async move { let access = state.operation_access(&binding, proof).await?; + let recipient = target + .recipient() + .ok_or(OperationError::UnsupportedOperation)?; let view = state.read_view(operation).await?; let t0 = state.operation_records(&view, operation).await?; let facts = state @@ -165,7 +168,8 @@ impl BrowserWorkspace { .delivery_observations() .iter() .filter(|value| { - value.work().recipient() == recipient && value.request_id() == &request + value.work().recipient() == Some(recipient) + && value.request_id() == &request }) .cloned() .collect() diff --git a/crates/storage_indexeddb/src/workspace/delivery/operations.rs b/crates/storage_indexeddb/src/workspace/delivery/operations.rs @@ -4,7 +4,7 @@ use crate::workspace::{ journal::OperationChange, owned, }; use nostr::JsonUtil; -use radroots_domain::{CommandDigest, OperationId, PublicKey, TransactionId}; +use radroots_domain::{CommandDigest, OperationId, TransactionId}; use radroots_storage::{ command::{ ArtifactEvidence, BoundSigningPlan, CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, @@ -81,7 +81,7 @@ impl BrowserWorkspace { let state = self.state.clone(); let result = owned(work, async move { let access = state.operation_access(request.binding(), proof).await?; - let actual = request.work(); + let actual = request.work().private()?; let evidence = actual.evidence(); let operation = evidence.operation_id(); let view = state.read_view(operation).await?; @@ -123,7 +123,7 @@ impl BrowserWorkspace { .as_ref() .filter(|value| value.intent().request_id() == request.intent().request_id()); if let Some(retained) = retained - && (retained.work() != actual + && (retained.work().private()? != actual || retained.intent().digest() != request.intent().digest() || candidate.as_ref().is_some_and(|value| { value.work() != actual || value.raw_json() != retained.raw_json() @@ -135,7 +135,7 @@ impl BrowserWorkspace { let (report, extra) = if fresh { routes(bound, evidence.recipient()?, request.intent())?; if snapshot.delivery_attempts().iter().any(|value| { - value.work() == actual + value.work().private().ok() == Some(actual) && value.intent().publication_policy_digest() != request.intent().publication_policy_digest() }) { @@ -162,7 +162,7 @@ impl BrowserWorkspace { let count = snapshot .delivery_attempts() .iter() - .filter(|value| value.work() == actual) + .filter(|value| value.work().private().ok() == Some(actual)) .flat_map(|value| value.intent().selected_targets()) .filter(|old| old.uri() == target.uri()) .count(); @@ -190,7 +190,7 @@ impl BrowserWorkspace { .selected .as_ref() .filter(|value| { - value.work() == actual + value.work().private().ok() == Some(actual) && value.intent().event_id() == request.intent().event_id() }) .ok_or(OperationError::InvalidEvidence)?; @@ -288,7 +288,7 @@ impl BrowserWorkspace { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: radroots_storage::command::SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> Result<Option<DeliveryAttempt>, OperationError> { @@ -299,6 +299,9 @@ impl BrowserWorkspace { let state = self.state.clone(); owned(work, async move { let access = state.operation_access(&binding, proof).await?; + let recipient = target + .recipient() + .ok_or(OperationError::UnsupportedOperation)?; let view = state.read_view(operation).await?; let t0 = state.operation_records(&view, operation).await?; let facts = state diff --git a/crates/storage_indexeddb/src/workspace/issuance.rs b/crates/storage_indexeddb/src/workspace/issuance.rs @@ -24,7 +24,7 @@ use zeroize::Zeroizing; pub(super) enum Claim { Absent(BoundSigningPlan, u8), - Present(SigningAttempt), + Present(Box<SigningAttempt>), } fn position(bound: &BoundSigningPlan, recipient: PublicKey) -> Result<Option<u8>, OperationError> { Ok(bound @@ -124,7 +124,7 @@ impl State { ) .await?; let attempt = clear.expose_secret(|raw| ClaimRecord::decode(raw, bound, recipient))?; - Ok(Claim::Present(attempt)) + Ok(Claim::Present(Box::new(attempt))) } pub(super) async fn evidence( &self, @@ -276,7 +276,7 @@ impl BrowserWorkspace { .claim(&view, bound, request.recipient()?, index) .await? { - Claim::Present(attempt) => (attempt, false, Vec::new()), + Claim::Present(attempt) => (*attempt, false, Vec::new()), Claim::Absent(bound, index) => { state .check_claim_absence( @@ -376,7 +376,7 @@ impl BrowserWorkspace { .claim(&view, bound, request.recipient()?, index) .await? { - Claim::Present(attempt) => Some(attempt), + Claim::Present(attempt) => Some(*attempt), Claim::Absent(_, _) => { state .check_claim_absence( @@ -555,7 +555,7 @@ impl BrowserWorkspace { obtained .map(|(evidence, receipt)| { CapturedArtifact::from_committed_store( - attempt, + *attempt, evidence, receipt.transaction_id(), ) diff --git a/crates/storage_indexeddb/src/workspace/ports.rs b/crates/storage_indexeddb/src/workspace/ports.rs @@ -1,6 +1,6 @@ //! Shared journal dispatch uses the actual browser owner, never another engine. use super::BrowserWorkspace; -use radroots_domain::{CommandDigest, OperationId, PublicKey}; +use radroots_domain::{CommandDigest, OperationId}; use radroots_storage::{ command::{ AdmissionOutcome, AdmissionRequest, ArtifactEvidence, BoundSigningPlan, CapturedArtifact, @@ -8,7 +8,7 @@ use radroots_storage::{ DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryObservation, DeliveryObservationOutcome, EnvelopeCandidate, EvidenceCaptureOutcome, InstallationOutcome, InstallationRequest, OperationError, OperationJournal, OperationSnapshot, - PlanBindingOutcome, PreparedOperation, SigningAttempt, + PlanBindingOutcome, PreparedOperation, SigningAttempt, SigningTarget, }, workspace::{AttachmentInput, AttachmentProof, WorkspaceBinding}, }; @@ -43,12 +43,12 @@ impl OperationJournal for BrowserWorkspace { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> BoxFuture<'_, Result<Vec<DeliveryObservation>, OperationError>> { Box::pin(BrowserWorkspace::delivery_observations( - self, binding, operation, digest, recipient, request, proof, + self, binding, operation, digest, target, request, proof, )) } fn prepare_delivery_attempt<'a>( @@ -66,12 +66,12 @@ impl OperationJournal for BrowserWorkspace { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> BoxFuture<'_, Result<Option<DeliveryAttempt>, OperationError>> { Box::pin(BrowserWorkspace::delivery_attempt( - self, binding, operation, digest, recipient, request, proof, + self, binding, operation, digest, target, request, proof, )) } fn install_transition_and_outbox( diff --git a/crates/storage_indexeddb/src/workspace/recovery.rs b/crates/storage_indexeddb/src/workspace/recovery.rs @@ -2,7 +2,7 @@ use super::{Database, OpenMode, State, WorkspaceError, namespace, stored}; use radroots_domain::OperationId; use radroots_storage::command::{ - ArtifactEvidence, DeliveryObservation, DeliveryObservationKind, PublicationWork, + ArtifactEvidence, DeliveryObservation, DeliveryObservationKind, PublicationArtifact, }; use radroots_storage::workspace::{ AttachmentInput, AttachmentProof, local_outbox::LocalOutboxGrant, @@ -16,7 +16,7 @@ pub(super) enum CaptureIdentity { digest: [u8; 32], }, Observation { - work: Box<PublicationWork>, + work: Box<PublicationArtifact>, request: DeliveryRequestId, target: TargetFingerprint, kind: DeliveryObservationKind, diff --git a/crates/storage_indexeddb/src/workspace/retained.rs b/crates/storage_indexeddb/src/workspace/retained.rs @@ -104,7 +104,7 @@ impl Graph { Some(claim), receipt, )); - bound = attempt.into_bound_plan(); + bound = (*attempt).into_bound_plan(); } } } diff --git a/crates/storage_indexeddb/tests/browser/src/workspace/delivery.rs b/crates/storage_indexeddb/tests/browser/src/workspace/delivery.rs @@ -293,7 +293,7 @@ impl WorkspaceFixture { request.binding().clone(), OperationId::from_bytes([n; 32]), request.command().digest(), - recipient, + recipient.into(), DeliveryRequestId::parse(hex::encode([id; 32])).unwrap(), copied(&self.proof), ) diff --git a/crates/storage_indexeddb/tests/browser/src/workspace/observations.rs b/crates/storage_indexeddb/tests/browser/src/workspace/observations.rs @@ -17,7 +17,7 @@ use wasm_bindgen::prelude::*; fn summary(value: &DeliveryObservation) -> Value { let target = value.target_receipt(); let outcome = target.outcome(); - json!({"request":value.request_id().as_str(),"event":value.event_id().to_string(),"digest":hex::encode(value.envelope_digest()),"recipient":value.work().recipient().to_string(),"capture":value.work().evidence().transaction_id().to_string(),"work":value.work().transaction_id().to_string(),"target":target.target().uri().as_str(),"fingerprint":target.target().fingerprint().as_str(),"attempted":target.was_attempted(),"class":value.kind().code(),"ordinal":value.target_ordinal(),"at":value.observed_at_unix_ms().map(|t|t.get()),"code":outcome.code(),"message":outcome.message()}) + json!({"request":value.request_id().as_str(),"event":value.event_id().to_string(),"digest":hex::encode(value.envelope_digest()),"recipient":value.work().private().unwrap().recipient().to_string(),"capture":value.work().evidence().transaction_id().to_string(),"work":value.work().transaction_id().to_string(),"target":target.target().uri().as_str(),"fingerprint":target.target().fingerprint().as_str(),"attempted":target.was_attempted(),"class":value.kind().code(),"ordinal":value.target_ordinal(),"at":value.observed_at_unix_ms().map(|t|t.get()),"code":outcome.code(),"message":outcome.message()}) } fn result(value: DeliveryObservationOutcome) -> String { match value { @@ -65,7 +65,7 @@ impl WorkspaceFixture { request.binding().clone(), OperationId::from_bytes([n; 32]), request.command().digest(), - recipients[index as usize], + recipients[index as usize].into(), DeliveryRequestId::parse(hex::encode([id; 32])).unwrap(), copied(&self.proof), ) @@ -160,7 +160,7 @@ impl WorkspaceFixture { request.binding().clone(), OperationId::from_bytes([n; 32]), request.command().digest(), - recipients[index as usize], + recipients[index as usize].into(), DeliveryRequestId::parse(hex::encode([id; 32])).unwrap(), copied(&self.proof), ) @@ -179,7 +179,7 @@ impl WorkspaceFixture { original.binding.clone(), evidence.operation_id(), evidence.command_digest(), - evidence.recipient().unwrap(), + evidence.target(), original.value.request_id().clone(), copied(&self.proof), ) diff --git a/crates/storage_sqlite/src/workspace/attempt.rs b/crates/storage_sqlite/src/workspace/attempt.rs @@ -150,11 +150,16 @@ pub(super) async fn sql( .map_err(|_| OperationError::RecoveryRequired)?; match version { 7 | 8 => Ok(sqlx::AssertSqlSafe(legacy.to_owned())), - 9 | 10 => Ok(sqlx::AssertSqlSafe( - legacy + 9..=11 => { + let query = legacy .replace("seal_evidence", "artifact_evidence") - .replace("recipient", "artifact_key"), - )), + .replace("recipient", "artifact_key"); + Ok(sqlx::AssertSqlSafe(if version == 11 { + query.replace("chat_delivery", "artifact_delivery") + } else { + query + })) + } _ => Err(OperationError::RecoveryRequired), } } @@ -167,7 +172,7 @@ pub(super) async fn require_target( .fetch_one(connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - if !matches!(version, 9 | 10) { + if !matches!(version, 9..=11) { return Err(OperationError::UnsupportedOperation); } } diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs @@ -35,7 +35,7 @@ pub(super) enum IssuancePayload { pub(super) struct DeliveryScope { pub workspace: WorkspaceId, pub operation: OperationId, - pub recipient: radroots_domain::PublicKey, + pub target: radroots_storage::command::SigningTarget, pub request: [u8; 32], } #[derive(Clone, Copy)] @@ -336,7 +336,7 @@ fn delivery_context( part: u8, ) -> Result<EnvelopeContext, WorkspaceError> { use sha2::{Digest, Sha256}; - let (tag, purpose, schema) = match payload { + let (tag, mut purpose, mut schema) = match payload { DeliveryPayload::Attempt => ( 0u8, "radroots.workspace.delivery_attempt", @@ -353,7 +353,24 @@ fn delivery_context( hash.update([tag, part]); hash.update(scope.workspace.as_bytes()); hash.update(scope.operation.as_bytes()); - hash.update(scope.recipient.as_bytes()); + match scope.target { + radroots_storage::command::SigningTarget::BusinessSeal(peer) => { + hash.update(peer.as_bytes()) + } + radroots_storage::command::SigningTarget::PublicEvent => { + hash.update(b"public_event.no_recipient.v1\0"); + (purpose, schema) = match payload { + DeliveryPayload::Attempt => ( + "radroots.workspace.public_delivery_attempt", + "radroots.workspace.public_delivery_attempt.v1", + ), + DeliveryPayload::Observation => ( + "radroots.workspace.public_delivery_observation", + "radroots.workspace.public_delivery_observation.v1", + ), + }; + } + } hash.update(scope.request); let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into()); Ok(EnvelopeContext::new( diff --git a/crates/storage_sqlite/src/workspace/delivery/codec.rs b/crates/storage_sqlite/src/workspace/delivery/codec.rs @@ -4,7 +4,9 @@ use super::super::{ }; use super::{MAX_BYTES, MAX_PROTECTED_BYTES}; use radroots_domain::{EnvelopeEventId, TransactionId, UnixSeconds}; -use radroots_storage::command::{DeliveryAttempt, DeliveryIntent, OperationError, PublicationWork}; +use radroots_storage::command::{ + DeliveryAttempt, DeliveryIntent, OperationError, PublicationArtifact, PublicationWork, +}; use radroots_transport::{TargetSet, policy::SatisfactionPolicy}; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; @@ -17,14 +19,14 @@ mod tests; #[derive(Serialize, Deserialize, Eq, PartialEq)] #[serde(deny_unknown_fields)] -pub(super) struct WorkRef { +pub(super) struct PrivateWorkRef { installation: TransactionId, plan: [u8; 32], evidence: EvidenceRef, transaction: TransactionId, queued_at: UnixSeconds, } -impl WorkRef { +impl PrivateWorkRef { pub(super) fn new(work: PublicationWork) -> Self { Self { installation: work.installation_transaction_id(), @@ -38,6 +40,69 @@ impl WorkRef { #[derive(Serialize, Deserialize, Eq, PartialEq)] #[serde(deny_unknown_fields)] +pub(super) struct PublicWorkRef { + role: u8, + #[serde(deserialize_with = "required_recipient")] + recipient: Option<radroots_domain::PublicKey>, + installation: TransactionId, + plan: [u8; 32], + evidence: super::super::listing_installation::PublicEvidenceRef, + transaction: TransactionId, + queued_at: UnixSeconds, +} +fn required_recipient<'de, D: serde::Deserializer<'de>>( + d: D, +) -> Result<Option<radroots_domain::PublicKey>, D::Error> { + Option::<radroots_domain::PublicKey>::deserialize(d) +} +#[derive(Serialize, Deserialize, Eq, PartialEq)] +#[serde(untagged)] +pub(super) enum WorkRef { + Private(PrivateWorkRef), + Public(PublicWorkRef), +} +impl WorkRef { + pub(super) fn new(work: impl Into<PublicationArtifact>) -> Self { + match work.into() { + PublicationArtifact::Private(v) => Self::Private(PrivateWorkRef::new(v)), + PublicationArtifact::Public(v) => Self::Public(PublicWorkRef { + role: 0, + recipient: None, + installation: v.installation_transaction_id(), + plan: *v.plan_digest(), + evidence: super::super::listing_installation::PublicEvidenceRef::new(v.evidence()), + transaction: v.transaction_id(), + queued_at: v.queued_at(), + }), + } + } +} +fn version(work: PublicationArtifact) -> u8 { + match work { + PublicationArtifact::Private(_) => 1, + PublicationArtifact::Public(_) => 2, + } +} +fn intent( + work: PublicationArtifact, + request: &str, + event: EnvelopeEventId, + targets: &TargetSet, + policy: &SatisfactionPolicy, + deadline: core::num::NonZeroU64, +) -> Result<DeliveryIntent, OperationError> { + match work { + PublicationArtifact::Private(_) => { + DeliveryIntent::new(request, event, targets, policy, deadline) + } + PublicationArtifact::Public(_) => { + DeliveryIntent::public(request, event, targets, policy, deadline) + } + } +} + +#[derive(Serialize, Deserialize, Eq, PartialEq)] +#[serde(deny_unknown_fields)] struct Header { version: u8, work: WorkRef, @@ -59,7 +124,7 @@ struct Header { impl Header { fn new(value: &DeliveryAttempt) -> Self { Self { - version: 1, + version: version(value.work()), work: WorkRef::new(value.work()), request: value.intent().request_id().as_str().into(), event: value.intent().event_id(), @@ -75,13 +140,14 @@ impl Header { } fn into_attempt( self, - work: PublicationWork, + work: PublicationArtifact, raw: &str, ) -> Result<DeliveryAttempt, OperationError> { - if self.version != 1 || self.work != WorkRef::new(work) { + if self.version != version(work) || self.work != WorkRef::new(work) { return Err(OperationError::RecoveryRequired); } - let intent = DeliveryIntent::new( + let intent = intent( + work, &self.request, self.event, &self.targets, @@ -143,12 +209,12 @@ pub(super) fn request_key(request: &str) -> [u8; 32] { hash.update(request.as_bytes()); hash.finalize().into() } -pub(super) fn scope(work: PublicationWork, key: [u8; 32]) -> DeliveryScope { +pub(super) fn scope(work: PublicationArtifact, key: [u8; 32]) -> DeliveryScope { let e = work.evidence(); DeliveryScope { workspace: e.workspace_id(), operation: e.operation_id(), - recipient: work.recipient(), + target: work.target(), request: key, } } @@ -239,7 +305,7 @@ pub(super) async fn protect( parts.push(protected); } let manifest = Manifest { - version: 1, + version: version(report.work()), work: WorkRef::new(report.work()), request: report.intent().request_id().as_str().into(), event: report.intent().event_id(), @@ -269,13 +335,13 @@ pub(super) async fn protect( pub(super) async fn read( connection: &mut SqliteConnection, - work: PublicationWork, + work: PublicationArtifact, key: [u8; 32], crypto: &WorkspaceCrypto, ) -> Result<Option<ProtectedAttempt>, OperationError> { let s = scope(work, key); - let row=sqlx::query("SELECT CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=?") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).fetch_optional(&mut *connection).await.map_err(invalid)?; + let row=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=?").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_optional(&mut *connection).await.map_err(invalid)?; let Some(row) = row else { return Ok(None) }; let event = bytes(&row, 0)?; let transaction = bytes(&row, 1)?; @@ -288,8 +354,8 @@ pub(super) async fn read( { return Err(OperationError::RecoveryRequired); } - let totals:(i64,i64)=sqlx::query_as("SELECT count(*),coalesce(sum(n),0) FROM (SELECT length(protected) AS n FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? LIMIT 25)") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).fetch_one(&mut *connection).await.map_err(invalid)?; + let totals:(i64,i64)=sqlx::query_as(super::sql(connection,"SELECT count(*),coalesce(sum(n),0) FROM (SELECT length(protected) AS n FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? LIMIT 25)").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_one(&mut *connection).await.map_err(invalid)?; if totals.0 != count || totals.1 <= 0 || (totals.1 as usize) @@ -307,7 +373,7 @@ pub(super) async fn read( } serde_json::from_slice(raw).map_err(invalid) })?; - if value.version != 1 + if value.version != version(work) || value.work != WorkRef::new(work) || request_key(&value.request) != key || value.event.as_bytes().as_slice() != event @@ -317,8 +383,8 @@ pub(super) async fn read( { return Err(OperationError::RecoveryRequired); } - let rows=sqlx::query("SELECT part,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? ORDER BY part LIMIT 25") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).fetch_all(&mut *connection).await.map_err(invalid)?; + let rows=sqlx::query(super::sql(connection,"SELECT part,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? ORDER BY part LIMIT 25").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_all(&mut *connection).await.map_err(invalid)?; let mut parts = Vec::with_capacity(rows.len()); let mut plain = Zeroizing::new(Vec::with_capacity(value.bytes)); for (index, row) in rows.iter().enumerate() { @@ -383,11 +449,11 @@ pub(super) async fn insert( value.report.work(), request_key(value.report.intent().request_id().as_str()), ); - sqlx::query("INSERT INTO chat_delivery_attempts(workspace,operation_id,recipient,request_key,event_id,transaction_id,part_count,byte_count,protected) VALUES(?,?,?,?,?,?,?,?,?)") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).bind(value.report.intent().event_id().as_bytes().as_slice()).bind(value.report.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; + sqlx::query(super::sql(connection,"INSERT INTO chat_delivery_attempts(workspace,operation_id,recipient,request_key,event_id,transaction_id,part_count,byte_count,protected) VALUES(?,?,?,?,?,?,?,?,?)").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(value.report.intent().event_id().as_bytes().as_slice()).bind(value.report.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; for (index, part) in value.parts.iter().enumerate() { - sqlx::query("INSERT INTO chat_delivery_parts(workspace,operation_id,recipient,request_key,part,protected) VALUES(?,?,?,?,?,?)") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).bind(index as i64+1).bind(part).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; + sqlx::query(super::sql(connection,"INSERT INTO chat_delivery_parts(workspace,operation_id,recipient,request_key,part,protected) VALUES(?,?,?,?,?,?)").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(index as i64+1).bind(part).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; } Ok(()) } @@ -398,8 +464,8 @@ impl Fact { connection: &mut SqliteConnection, ) -> Result<(), OperationError> { let s = self.scope; - let row=sqlx::query("SELECT CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=?") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).fetch_optional(&mut *connection).await.map_err(invalid)?.ok_or(OperationError::RecoveryRequired)?; + let row=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=?").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_optional(&mut *connection).await.map_err(invalid)?.ok_or(OperationError::RecoveryRequired)?; if bytes(&row, 0)? != self.event.as_bytes() || bytes(&row, 1)? != self.transaction.as_bytes() || row.try_get::<i64, _>(2).map_err(invalid)? != self.parts.len() as i64 @@ -411,14 +477,14 @@ impl Fact { // Compare one bounded ciphertext at a time. No provider, decryption, // signing or network operation occurs while holding the write fence. for (index, expected) in self.parts.iter().enumerate() { - let row=sqlx::query("SELECT CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? AND part=?") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).bind(index as i64+1).fetch_optional(&mut *connection).await.map_err(invalid)?.ok_or(OperationError::RecoveryRequired)?; + let row=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? AND part=?").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(index as i64+1).fetch_optional(&mut *connection).await.map_err(invalid)?.ok_or(OperationError::RecoveryRequired)?; if <[u8; 32]>::from(Sha256::digest(bytes(&row, 0)?)) != *expected { return Err(OperationError::RecoveryRequired); } } - let count:i64=sqlx::query_scalar("SELECT count(*) FROM (SELECT 1 FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? LIMIT 25)") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).fetch_one(connection).await.map_err(invalid)?; + let count:i64=sqlx::query_scalar(super::sql(connection,"SELECT count(*) FROM (SELECT 1 FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? LIMIT 25)").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_one(connection).await.map_err(invalid)?; if count != self.parts.len() as i64 { return Err(OperationError::RecoveryRequired); } @@ -428,12 +494,12 @@ impl Fact { pub(super) async fn absent( connection: &mut SqliteConnection, - work: PublicationWork, + work: PublicationArtifact, key: [u8; 32], ) -> Result<(), OperationError> { let s = scope(work, key); - let count:i64=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3 AND request_key=?4)+EXISTS(SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3 AND request_key=?4)") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).fetch_one(connection).await.map_err(invalid)?; + let count:i64=sqlx::query_scalar(super::sql(connection,"SELECT EXISTS(SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3 AND request_key=?4)+EXISTS(SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3 AND request_key=?4)").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_one(connection).await.map_err(invalid)?; if count != 0 { return Err(OperationError::RecoveryRequired); } diff --git a/crates/storage_sqlite/src/workspace/delivery/codec_tests.rs b/crates/storage_sqlite/src/workspace/delivery/codec_tests.rs @@ -5,6 +5,7 @@ mod cases { use crate::workspace::tests::issuance_records::{DeliveryData, delivery_data}; use nostr::JsonUtil; use serde_json::{Value, json}; + use sqlx::Connection; fn copy(report: &DeliveryAttempt) -> DeliveryAttempt { DeliveryAttempt::from_store_report( @@ -18,11 +19,11 @@ mod cases { .unwrap() } async fn restore(data: &mut DeliveryData, original: &ProtectedAttempt) { - sqlx::query("DELETE FROM chat_delivery_parts") + sqlx::query("DELETE FROM artifact_delivery_parts") .execute(&mut data.database) .await .unwrap(); - sqlx::query("DELETE FROM chat_delivery_attempts") + sqlx::query("DELETE FROM artifact_delivery_attempts") .execute(&mut data.database) .await .unwrap(); @@ -51,7 +52,7 @@ mod cases { ) .await .unwrap(); - sqlx::query("UPDATE chat_delivery_attempts SET protected=?") + sqlx::query("UPDATE artifact_delivery_attempts SET protected=?") .bind(protected) .execute(&mut data.database) .await @@ -64,7 +65,7 @@ mod cases { request_key(data.report.intent().request_id().as_str()), ); let pieces = raw.len().div_ceil(PRIVATE_PAYLOAD_MAX_BYTES); - let value = json!({"version":1,"work":WorkRef::new(data.report.work()),"request":data.report.intent().request_id().as_str(),"event":data.report.intent().event_id(),"transaction":data.report.transaction_id(),"parts":pieces,"bytes":raw.len(),"digest":<[u8;32]>::from(Sha256::digest(raw))}); + let value = json!({"version":version(data.report.work()),"work":WorkRef::new(data.report.work()),"request":data.report.intent().request_id().as_str(),"event":data.report.intent().event_id(),"transaction":data.report.transaction_id(),"parts":pieces,"bytes":raw.len(),"digest":<[u8;32]>::from(Sha256::digest(raw))}); let protected = data .crypto .seal_delivery( @@ -75,7 +76,7 @@ mod cases { ) .await .unwrap(); - sqlx::query("DELETE FROM chat_delivery_parts") + sqlx::query("DELETE FROM artifact_delivery_parts") .execute(&mut data.database) .await .unwrap(); @@ -85,9 +86,9 @@ mod cases { .seal_delivery(selected, DeliveryPayload::Attempt, (index + 1) as u8, piece) .await .unwrap(); - sqlx::query("INSERT INTO chat_delivery_parts(workspace,operation_id,recipient,request_key,part,protected) VALUES(?,?,?,?,?,?)").bind(selected.workspace.as_bytes().as_slice()).bind(selected.operation.as_bytes().as_slice()).bind(selected.recipient.as_bytes().as_slice()).bind(selected.request.as_slice()).bind(index as i64+1).bind(protected).execute(&mut data.database).await.unwrap(); + sqlx::query("INSERT INTO artifact_delivery_parts(workspace,operation_id,artifact_key,request_key,part,protected) VALUES(?,?,?,?,?,?)").bind(selected.workspace.as_bytes().as_slice()).bind(selected.operation.as_bytes().as_slice()).bind(selected.target.key().as_slice()).bind(selected.request.as_slice()).bind(index as i64+1).bind(protected).execute(&mut data.database).await.unwrap(); } - sqlx::query("UPDATE chat_delivery_attempts SET part_count=?,byte_count=?,protected=?") + sqlx::query("UPDATE artifact_delivery_attempts SET part_count=?,byte_count=?,protected=?") .bind(pieces as i64) .bind(raw.len() as i64) .bind(protected) @@ -158,21 +159,21 @@ mod cases { manifest(&mut data, &original, &nested).await; refused(&mut data).await; for statement in [ - "UPDATE chat_delivery_attempts SET event_id=zeroblob(31)", - "UPDATE chat_delivery_attempts SET transaction_id=zeroblob(31)", - "UPDATE chat_delivery_attempts SET event_id=zeroblob(32)", - "UPDATE chat_delivery_attempts SET transaction_id=zeroblob(32)", - "UPDATE chat_delivery_attempts SET part_count=0", - "UPDATE chat_delivery_attempts SET part_count=25", - "UPDATE chat_delivery_attempts SET byte_count=0", - "UPDATE chat_delivery_attempts SET byte_count=393217", - "UPDATE chat_delivery_attempts SET byte_count=1", - "UPDATE chat_delivery_attempts SET protected=zeroblob(262145)", - "DELETE FROM chat_delivery_parts WHERE part=1", - "UPDATE chat_delivery_parts SET part=0 WHERE part=1", - "UPDATE chat_delivery_parts SET protected=zeroblob(262145) WHERE part=1", - "UPDATE chat_delivery_parts SET protected=zeroblob(1) WHERE part=1", - "UPDATE chat_delivery_parts SET protected=zeroblob(0)", + "UPDATE artifact_delivery_attempts SET event_id=zeroblob(31)", + "UPDATE artifact_delivery_attempts SET transaction_id=zeroblob(31)", + "UPDATE artifact_delivery_attempts SET event_id=zeroblob(32)", + "UPDATE artifact_delivery_attempts SET transaction_id=zeroblob(32)", + "UPDATE artifact_delivery_attempts SET part_count=0", + "UPDATE artifact_delivery_attempts SET part_count=25", + "UPDATE artifact_delivery_attempts SET byte_count=0", + "UPDATE artifact_delivery_attempts SET byte_count=393217", + "UPDATE artifact_delivery_attempts SET byte_count=1", + "UPDATE artifact_delivery_attempts SET protected=zeroblob(262145)", + "DELETE FROM artifact_delivery_parts WHERE part=1", + "UPDATE artifact_delivery_parts SET part=0 WHERE part=1", + "UPDATE artifact_delivery_parts SET protected=zeroblob(262145) WHERE part=1", + "UPDATE artifact_delivery_parts SET protected=zeroblob(1) WHERE part=1", + "UPDATE artifact_delivery_parts SET protected=zeroblob(0)", ] { restore(&mut data, &original).await; sqlx::query(statement) @@ -187,7 +188,7 @@ mod cases { } restore(&mut data, &original).await; let part = original.parts.len() + 1; - sqlx::query("INSERT INTO chat_delivery_parts SELECT workspace,operation_id,recipient,request_key,?,protected FROM chat_delivery_parts WHERE part=1").bind(part as i64).execute(&mut data.database).await.unwrap(); + sqlx::query("INSERT INTO artifact_delivery_parts SELECT workspace,operation_id,artifact_key,request_key,?,protected FROM artifact_delivery_parts WHERE part=1").bind(part as i64).execute(&mut data.database).await.unwrap(); assert!(fact.unchanged(&mut data.database).await.is_err()); refused(&mut data).await; restore(&mut data, &original).await; @@ -214,7 +215,7 @@ mod cases { .seal_delivery(selected, DeliveryPayload::Attempt, index as u8, &plain) .await .unwrap(); - sqlx::query("UPDATE chat_delivery_parts SET protected=? WHERE part=?") + sqlx::query("UPDATE artifact_delivery_parts SET protected=? WHERE part=?") .bind(changed) .bind(index as i64) .execute(&mut data.database) @@ -223,14 +224,14 @@ mod cases { refused(&mut data).await; restore(&mut data, &original).await; } - sqlx::query("DELETE FROM chat_delivery_parts") + sqlx::query("DELETE FROM artifact_delivery_parts") .execute(&mut data.database) .await .unwrap(); for index in 1..=24i64 { - sqlx::query("INSERT INTO chat_delivery_parts(workspace,operation_id,recipient,request_key,part,protected) VALUES(?,?,?,?,?,zeroblob(262144))").bind(selected.workspace.as_bytes().as_slice()).bind(selected.operation.as_bytes().as_slice()).bind(selected.recipient.as_bytes().as_slice()).bind(selected.request.as_slice()).bind(index).execute(&mut data.database).await.unwrap(); + sqlx::query("INSERT INTO artifact_delivery_parts(workspace,operation_id,artifact_key,request_key,part,protected) VALUES(?,?,?,?,?,zeroblob(262144))").bind(selected.workspace.as_bytes().as_slice()).bind(selected.operation.as_bytes().as_slice()).bind(selected.target.key().as_slice()).bind(selected.request.as_slice()).bind(index).execute(&mut data.database).await.unwrap(); } - sqlx::query("UPDATE chat_delivery_attempts SET part_count=24,byte_count=393216") + sqlx::query("UPDATE artifact_delivery_attempts SET part_count=24,byte_count=393216") .execute(&mut data.database) .await .unwrap(); @@ -355,4 +356,105 @@ mod cases { data.report.raw_json() ); } + #[tokio::test] + async fn public_delivery_metadata_requires_role_and_explicit_absent_recipient_in_each_frame() { + use crate::workspace::tests::issuance_records::public_delivery_data; + use radroots_storage::command::SigningTarget; + let mut data = public_delivery_data().await; + let original = protect(copy(&data.report), &data.crypto).await.unwrap(); + insert(&mut data.database, &original).await.unwrap(); + let key = request_key(data.report.intent().request_id().as_str()); + let selected = scope(data.report.work(), key); + let plain = data + .crypto + .open_delivery(selected, DeliveryPayload::Attempt, 0, &original.manifest) + .await + .unwrap(); + let base: Value = plain.expose_secret(|v| serde_json::from_slice(v).unwrap()); + let header = serde_json::to_value(Header::new(&data.report)).unwrap(); + assert_eq!(base["version"], json!(2)); + assert_eq!(base["work"]["role"], json!(0)); + assert!(base["work"].as_object().unwrap().contains_key("recipient")); + assert!(base["work"]["recipient"].is_null()); + let mut mutants = Vec::new(); + for (field, value) in [ + ("role", json!(1)), + ("role", Value::Null), + ( + "recipient", + json!("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), + ), + ("unknown", json!(true)), + ] { + let mut value_work = base["work"].clone(); + value_work[field] = value; + mutants.push(value_work); + } + for field in ["role", "recipient"] { + let mut value_work = base["work"].clone(); + value_work.as_object_mut().unwrap().remove(field); + mutants.push(value_work); + } + // Include a real private work reference rather than a fabricated peer. + let private = delivery_data().await; + mutants.push(serde_json::to_value(WorkRef::new(private.report.work())).unwrap()); + for work in mutants { + restore(&mut data, &original).await; + let mut changed = base.clone(); + changed["work"] = work.clone(); + manifest(&mut data, &original, &changed).await; + refused(&mut data).await; + restore(&mut data, &original).await; + let mut changed = header.clone(); + changed["work"] = work; + let raw = data.report.raw_json().to_owned(); + frame(&mut data, &encoded(&changed, raw.as_bytes())).await; + refused(&mut data).await; + } + for is_header in [false, true] { + restore(&mut data, &original).await; + let mut changed = if is_header { + header.clone() + } else { + base.clone() + }; + changed["version"] = json!(1); + if is_header { + let raw = data.report.raw_json().to_owned(); + frame(&mut data, &encoded(&changed, raw.as_bytes())).await; + } else { + manifest(&mut data, &original, &changed).await; + } + refused(&mut data).await; + } + // Public/private and attempt/observation contexts cannot open each other's bytes. + let mut foreign = selected; + foreign.target = + SigningTarget::BusinessSeal(private.report.work().private().unwrap().recipient()); + assert!( + data.crypto + .open_delivery(foreign, DeliveryPayload::Attempt, 0, &original.manifest) + .await + .is_err() + ); + assert!( + data.crypto + .open_delivery( + selected, + DeliveryPayload::Observation, + 0, + &original.manifest + ) + .await + .is_err() + ); + restore(&mut data, &original).await; + let actual = read(&mut data.database, data.report.work(), key, &data.crypto) + .await + .unwrap() + .unwrap(); + assert_eq!(actual.report.raw_json(), data.report.raw_json()); + assert_eq!(actual.report.work(), data.report.work()); + private.database.close().await.unwrap(); + } } diff --git a/crates/storage_sqlite/src/workspace/delivery/graph.rs b/crates/storage_sqlite/src/workspace/delivery/graph.rs @@ -7,7 +7,8 @@ use super::{ }; use radroots_domain::{OperationId, PublicKey}; use radroots_storage::command::{ - BoundSigningPlan, DeliveryAttempt, DeliveryIntent, OperationError, SignedDmRelaySource, + BoundSigningPlan, DeliveryAttempt, DeliveryIntent, OperationError, PublicationArtifact, + SignedDmRelaySource, SigningTarget, }; use sqlx::{Row, SqliteConnection}; use std::collections::{BTreeMap, BTreeSet}; @@ -20,8 +21,8 @@ pub(in crate::workspace) struct Graph { pub attempts: Vec<DeliveryAttempt>, facts: Vec<Fact>, parts: usize, - counters: BTreeMap<(PublicKey, String), BTreeSet<u8>>, - routes: BTreeMap<PublicKey, BTreeSet<String>>, + counters: BTreeMap<(Option<PublicKey>, String), BTreeSet<u8>>, + routes: BTreeMap<Option<PublicKey>, BTreeSet<String>>, } fn bad<E>(_: E) -> OperationError { OperationError::RecoveryRequired @@ -36,14 +37,28 @@ fn keys(row: &sqlx::sqlite::SqliteRow, index: usize) -> Result<[u8; 32], Operati fn allowed_routes( bound: &BoundSigningPlan, - recipient: PublicKey, -) -> Result<BTreeMap<PublicKey, BTreeSet<String>>, OperationError> { + target: SigningTarget, +) -> Result<BTreeMap<Option<PublicKey>, BTreeSet<String>>, OperationError> { + let recipient = target.recipient(); + if target == SigningTarget::PublicEvent { + let plan = bound + .plan() + .listing() + .ok_or(OperationError::UnverifiedApproval)?; + return Ok(BTreeMap::from([( + None, + plan.selected_targets() + .iter() + .map(|v| v.as_ref().to_owned()) + .collect(), + )])); + } let mut result = BTreeMap::new(); for route in bound .chat_plan()? .routes() .iter() - .filter(|route| route.participant() == recipient) + .filter(|route| Some(route.participant()) == recipient) { let source = SignedDmRelaySource::verify(route.raw_json())?; source.validate_capture(route)?; @@ -52,7 +67,7 @@ fn allowed_routes( .iter() .map(|target| target.as_ref().to_owned()) .collect::<BTreeSet<_>>(); - if selected.is_empty() || result.insert(route.participant(), selected).is_some() { + if selected.is_empty() || result.insert(Some(route.participant()), selected).is_some() { return Err(OperationError::InvalidCommand); } } @@ -65,9 +80,10 @@ impl Graph { operation: OperationId, original: &RetainedGraph, installed: &Records, + public: &super::super::listing_installation::Records, crypto: &WorkspaceCrypto, ) -> Result<Self, OperationError> { - let rows=sqlx::query("SELECT CASE WHEN length(recipient)=32 THEN recipient END,CASE WHEN length(request_key)=32 THEN request_key END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? ORDER BY recipient,request_key LIMIT 385") + let rows=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(recipient)=32 OR (length(recipient)=1 AND hex(recipient)='00') THEN recipient END,CASE WHEN length(request_key)=32 THEN request_key END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? ORDER BY recipient,request_key LIMIT 385").await?) .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_all(&mut *connection).await.map_err(bad)?; if rows.len() > MAX_ATTEMPTS { return Err(OperationError::RecoveryRequired); @@ -84,7 +100,12 @@ impl Graph { let mut representations = BTreeMap::new(); let mut policies = BTreeMap::new(); for row in rows { - let recipient = PublicKey::from_bytes(keys(&row, 0)?).map_err(bad)?; + let key_bytes = row + .try_get::<Option<Vec<u8>>, _>(0) + .map_err(bad)? + .ok_or(OperationError::RecoveryRequired)?; + let target_scope = SigningTarget::from_key(&key_bytes).map_err(bad)?; + let recipient = target_scope.recipient(); let key = keys(&row, 1)?; if !result.routes.contains_key(&recipient) { result @@ -92,19 +113,37 @@ impl Graph { original .bound_plan() .ok_or(OperationError::RecoveryRequired)?, - recipient, + target_scope, ) .map_err(|_| OperationError::RecoveryRequired)?; } - let work = installed - .work - .iter() - .find(|work| work.report.recipient() == recipient) - .ok_or(OperationError::RecoveryRequired)? - .report; + let work = match target_scope { + SigningTarget::BusinessSeal(peer) => PublicationArtifact::Private( + installed + .work + .iter() + .find(|v| v.report.recipient() == peer) + .ok_or(OperationError::RecoveryRequired)? + .report, + ), + SigningTarget::PublicEvent => PublicationArtifact::Public( + public.work().ok_or(OperationError::RecoveryRequired)?, + ), + }; let value = codec::read(connection, work, key, crypto) .await? .ok_or(OperationError::RecoveryRequired)?; + if target_scope == SigningTarget::PublicEvent + && original + .obtained_artifact(target_scope) + .is_none_or(|source| { + source.raw_json() != value.report.raw_json() + || source.digest() != work.evidence().digest() + }) + { + return Err(OperationError::RecoveryRequired); + } + if policies .insert( recipient, @@ -130,7 +169,7 @@ impl Graph { .filter(|n| *n <= MAX_ATTEMPTS) .ok_or(OperationError::RecoveryRequired)?; result - .validate_routes(recipient, value.report.intent()) + .validate_routes(target_scope, value.report.intent()) .map_err(|_| OperationError::RecoveryRequired)?; for (target, ordinal) in value .report @@ -159,12 +198,12 @@ impl Graph { } pub(super) fn validate_routes( &self, - recipient: PublicKey, + target: SigningTarget, intent: &DeliveryIntent, ) -> Result<(), OperationError> { let routes = self .routes - .get(&recipient) + .get(&target.recipient()) .ok_or(OperationError::UnverifiedApproval)?; if intent.targets().targets().iter().any(|target| { !routes @@ -178,10 +217,10 @@ impl Graph { pub(super) fn authorize_routes( &mut self, bound: &BoundSigningPlan, - recipient: PublicKey, + target: SigningTarget, ) -> Result<(), OperationError> { - let routes = allowed_routes(bound, recipient)?; - if !routes.contains_key(&recipient) { + let routes = allowed_routes(bound, target)?; + if !routes.contains_key(&target.recipient()) { return Err(OperationError::UnverifiedApproval); } self.routes.extend(routes); @@ -189,16 +228,17 @@ impl Graph { } pub(super) fn ordinals( &self, - recipient: PublicKey, + target: SigningTarget, intent: &DeliveryIntent, ) -> Result<Vec<u8>, OperationError> { - self.validate_routes(recipient, intent)?; + self.validate_routes(target, intent)?; + let target_scope = target.recipient(); intent .selected_targets() .map(|target| { let count = self .counters - .get(&(recipient, target.uri().as_str().to_owned())) + .get(&(target_scope, target.uri().as_str().to_owned())) .map_or(0, BTreeSet::len); if count >= 12 { return Err(OperationError::DeliveryAttemptLimit); @@ -213,7 +253,7 @@ impl Graph { selected: &AttachmentInput, operation: OperationId, ) -> Result<(), OperationError> { - let counts:(i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM (SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2 LIMIT 385)),(SELECT count(*) FROM (SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2 LIMIT 9217))") + let counts:(i64,i64)=sqlx::query_as(super::sql(connection,"SELECT (SELECT count(*) FROM (SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2 LIMIT 385)),(SELECT count(*) FROM (SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2 LIMIT 9217))").await?) .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *connection).await.map_err(bad)?; if counts != (self.facts.len() as i64, self.parts as i64) { return Err(OperationError::RecoveryRequired); diff --git a/crates/storage_sqlite/src/workspace/delivery/graph_tests.rs b/crates/storage_sqlite/src/workspace/delivery/graph_tests.rs @@ -71,10 +71,11 @@ mod cases { #[tokio::test] async fn original_route_authentication_refuses_invalid_sources_and_unadvertised_selection() { let mut data = delivery_data().await; - let recipient = data.report.work().recipient(); + let artifact = data.report.work().target(); + let recipient = artifact.recipient(); let selected = [String::from("wss://route.example/")]; assert!( - allowed_routes(&data.bound().await, recipient) + allowed_routes(&data.bound().await, artifact) .unwrap() .contains_key(&recipient) ); @@ -105,7 +106,7 @@ mod cases { ] { let source = EnvelopeEventId::from_bytes(*event.id.as_bytes()); let bound = route_plan(data.bound().await, &event.as_json(), source, &selected); - assert!(allowed_routes(&bound, recipient).is_err()); + assert!(allowed_routes(&bound, artifact).is_err()); } let event = signed(10050, 99, 1, vec![relay()]); let source = EnvelopeEventId::from_bytes(*event.id.as_bytes()); @@ -115,17 +116,17 @@ mod cases { EnvelopeEventId::from_bytes([0; 32]), &selected, ); - assert!(allowed_routes(&bound, recipient).is_err()); + assert!(allowed_routes(&bound, artifact).is_err()); let missing = [String::from("wss://unadvertised.example/")]; let bound = route_plan(data.bound().await, &event.as_json(), source, &missing); assert!(matches!( - allowed_routes(&bound, recipient), + allowed_routes(&bound, artifact), Err(OperationError::UnverifiedApproval) )); let mut raw: serde_json::Value = serde_json::from_str(&event.as_json()).unwrap(); raw["sig"] = serde_json::Value::String("0".repeat(128)); let bound = route_plan(data.bound().await, &raw.to_string(), source, &selected); - assert!(allowed_routes(&bound, recipient).is_err()); + assert!(allowed_routes(&bound, artifact).is_err()); let metadata = signed( 10050, 99, @@ -139,19 +140,19 @@ mod cases { let source = EnvelopeEventId::from_bytes(*metadata.id.as_bytes()); let bound = route_plan(data.bound().await, &metadata.as_json(), source, &selected); assert!( - allowed_routes(&bound, recipient) + allowed_routes(&bound, artifact) .unwrap() .contains_key(&recipient) ); let bound = route_plan(data.bound().await, &metadata.as_json(), source, &missing); assert!(matches!( - allowed_routes(&bound, recipient), + allowed_routes(&bound, artifact), Err(OperationError::UnverifiedApproval) )); let unrelated = PublicKey::from_bytes(signed(10050, 99, 2, vec![relay()]).pubkey.to_bytes()).unwrap(); assert!( - allowed_routes(&data.bound().await, unrelated) + allowed_routes(&data.bound().await, unrelated.into()) .unwrap() .is_empty() ); @@ -160,7 +161,8 @@ mod cases { #[tokio::test] async fn route_scope_budget_and_complete_fact_count_fences_are_independent() { let mut data = delivery_data().await; - let recipient = data.report.work().recipient(); + let artifact = data.report.work().target(); + let recipient = artifact.recipient(); let mut graph = Graph { attempts: vec![], facts: vec![], @@ -170,22 +172,19 @@ mod cases { }; assert!( graph - .validate_routes(recipient, data.report.intent()) + .validate_routes(artifact, data.report.intent()) .is_err() ); graph - .authorize_routes(&data.bound().await, recipient) + .authorize_routes(&data.bound().await, artifact) .unwrap(); let unrelated = PublicKey::from_bytes(signed(10050, 99, 2, vec![relay()]).pubkey.to_bytes()).unwrap(); assert!(matches!( - graph.authorize_routes(&data.bound().await, unrelated), + graph.authorize_routes(&data.bound().await, unrelated.into()), Err(OperationError::UnverifiedApproval) )); - assert_eq!( - graph.ordinals(recipient, data.report.intent()).unwrap(), - [1] - ); + assert_eq!(graph.ordinals(artifact, data.report.intent()).unwrap(), [1]); let set = TargetSet::new(vec![ Target::nostr_relay("wss://unadvertised.example/").unwrap(), ]) @@ -198,7 +197,7 @@ mod cases { data.report.intent().deadline_unix_ms(), ) .unwrap(); - assert!(graph.validate_routes(recipient, &foreign).is_err()); + assert!(graph.validate_routes(artifact, &foreign).is_err()); graph.counters.insert( ( recipient, @@ -210,7 +209,7 @@ mod cases { (1..=12).collect(), ); assert!(matches!( - graph.ordinals(recipient, data.report.intent()), + graph.ordinals(artifact, data.report.intent()), Err(OperationError::DeliveryAttemptLimit) )); let selected = data.selection(); @@ -285,13 +284,13 @@ mod cases { .await .unwrap(); for statement in [ - "UPDATE chat_delivery_observations SET recipient=zeroblob(31)", - "UPDATE chat_delivery_observations SET recipient=zeroblob(32)", - "UPDATE chat_delivery_observations SET request_key=zeroblob(32)", - "UPDATE chat_delivery_observations SET target_key=zeroblob(31)", - "UPDATE chat_delivery_observations SET kind=7", - "UPDATE chat_delivery_observations SET protected=zeroblob(262145)", - "UPDATE chat_delivery_observations SET protected=zeroblob(1)", + "UPDATE artifact_delivery_observations SET artifact_key=zeroblob(31)", + "UPDATE artifact_delivery_observations SET artifact_key=zeroblob(32)", + "UPDATE artifact_delivery_observations SET request_key=zeroblob(32)", + "UPDATE artifact_delivery_observations SET target_key=zeroblob(31)", + "UPDATE artifact_delivery_observations SET kind=7", + "UPDATE artifact_delivery_observations SET protected=zeroblob(262145)", + "UPDATE artifact_delivery_observations SET protected=zeroblob(1)", ] { sqlx::query(statement) .execute(&mut data.database) @@ -314,13 +313,13 @@ mod cases { .await .is_err() ); - sqlx::query("DELETE FROM chat_delivery_observations") + sqlx::query("DELETE FROM artifact_delivery_observations") .execute(&mut data.database) .await .unwrap(); protected.insert(&mut data.database).await.unwrap(); } - sqlx::query("DELETE FROM chat_delivery_observations") + sqlx::query("DELETE FROM artifact_delivery_observations") .execute(&mut data.database) .await .unwrap(); @@ -335,14 +334,14 @@ mod cases { .execute(&mut data.database) .await .unwrap(); - sqlx::query("DELETE FROM chat_delivery_observations") + sqlx::query("DELETE FROM artifact_delivery_observations") .execute(&mut data.database) .await .unwrap(); for index in 0..2305u32 { let mut target = [0; 32]; target[..4].copy_from_slice(&index.to_be_bytes()); - sqlx::query("INSERT INTO chat_delivery_observations(workspace,operation_id,recipient,request_key,target_key,kind,protected) VALUES(?,?,?,?,?,1,x'01')").bind(e.workspace_id().as_bytes().as_slice()).bind(e.operation_id().as_bytes().as_slice()).bind(e.recipient().unwrap().as_bytes().as_slice()).bind(request.as_slice()).bind(target.as_slice()).execute(&mut data.database).await.unwrap(); + sqlx::query("INSERT INTO artifact_delivery_observations(workspace,operation_id,artifact_key,request_key,target_key,kind,protected) VALUES(?,?,?,?,?,1,x'01')").bind(e.workspace_id().as_bytes().as_slice()).bind(e.operation_id().as_bytes().as_slice()).bind(e.recipient().unwrap().as_bytes().as_slice()).bind(request.as_slice()).bind(target.as_slice()).execute(&mut data.database).await.unwrap(); } let error = observation::Observations::read( &mut data.database, diff --git a/crates/storage_sqlite/src/workspace/delivery/mod.rs b/crates/storage_sqlite/src/workspace/delivery/mod.rs @@ -7,11 +7,50 @@ pub(super) mod observation; mod observation_operations; mod operations; -pub(super) const TABLE: &str = "CREATE TABLE chat_delivery_attempts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), request_key BLOB NOT NULL CHECK(length(request_key)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 24), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 393216), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,request_key), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES chat_publication_work(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; -pub(super) const PARTS: &str = "CREATE TABLE chat_delivery_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, request_key BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 24), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,request_key,part), FOREIGN KEY(workspace,operation_id,recipient,request_key) REFERENCES chat_delivery_attempts(workspace,operation_id,recipient,request_key)) STRICT, WITHOUT ROWID"; -pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX chat_delivery_transaction_identity ON chat_delivery_attempts(workspace,transaction_id)"; +pub(super) const TABLE_V10: &str = "CREATE TABLE chat_delivery_attempts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), request_key BLOB NOT NULL CHECK(length(request_key)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 24), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 393216), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,request_key), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES chat_publication_work(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; +pub(super) const TABLE: &str = "CREATE TABLE artifact_delivery_attempts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL CHECK(length(artifact_key)=32 OR (length(artifact_key)=1 AND hex(artifact_key)='00')), request_key BLOB NOT NULL CHECK(length(request_key)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 24), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 393216), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key,request_key), FOREIGN KEY(workspace,operation_id,artifact_key) REFERENCES artifact_evidence(workspace,operation_id,artifact_key)) STRICT, WITHOUT ROWID"; +pub(super) const PARTS_V10: &str = "CREATE TABLE chat_delivery_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, request_key BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 24), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,request_key,part), FOREIGN KEY(workspace,operation_id,recipient,request_key) REFERENCES chat_delivery_attempts(workspace,operation_id,recipient,request_key)) STRICT, WITHOUT ROWID"; +pub(super) const PARTS: &str = "CREATE TABLE artifact_delivery_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL, request_key BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 24), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key,request_key,part), FOREIGN KEY(workspace,operation_id,artifact_key,request_key) REFERENCES artifact_delivery_attempts(workspace,operation_id,artifact_key,request_key)) STRICT, WITHOUT ROWID"; +pub(super) const TX_INDEX_V10: &str = "CREATE UNIQUE INDEX chat_delivery_transaction_identity ON chat_delivery_attempts(workspace,transaction_id)"; +pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX artifact_delivery_transaction_identity ON artifact_delivery_attempts(workspace,transaction_id)"; const MAX_BYTES: usize = 393216; const MAX_PROTECTED_BYTES: usize = 2 * 1024 * 1024; const MAX_ATTEMPTS: usize = 2 * 16 * 12; pub(super) const OBSERVATIONS: &str = observation::TABLE; +pub(super) const OBSERVATIONS_V10: &str = observation::TABLE_V10; + +/// Fixed identifier adaptation for exact retained catalogs, never user SQL. +pub(super) async fn sql( + connection: &mut sqlx::SqliteConnection, + legacy: &'static str, +) -> Result<sqlx::AssertSqlSafe<String>, radroots_storage::command::OperationError> { + let version: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(connection) + .await + .map_err(|_| radroots_storage::command::OperationError::RecoveryRequired)?; + match version { + 7..=10 => Ok(sqlx::AssertSqlSafe(legacy.to_owned())), + 11 => Ok(sqlx::AssertSqlSafe( + legacy + .replace("chat_delivery", "artifact_delivery") + .replace("recipient", "artifact_key"), + )), + _ => Err(radroots_storage::command::OperationError::RecoveryRequired), + } +} +pub(super) async fn require_target( + connection: &mut sqlx::SqliteConnection, + target: radroots_storage::command::SigningTarget, +) -> Result<(), radroots_storage::command::OperationError> { + if target == radroots_storage::command::SigningTarget::PublicEvent { + let version: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(connection) + .await + .map_err(|_| radroots_storage::command::OperationError::RecoveryRequired)?; + if version != 11 { + return Err(radroots_storage::command::OperationError::UnsupportedOperation); + } + } + Ok(()) +} diff --git a/crates/storage_sqlite/src/workspace/delivery/observation.rs b/crates/storage_sqlite/src/workspace/delivery/observation.rs @@ -15,7 +15,8 @@ use zeroize::Zeroizing; #[path = "observation_tests.rs"] mod tests; -pub(super) const TABLE: &str = "CREATE TABLE chat_delivery_observations (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, request_key BLOB NOT NULL, target_key BLOB NOT NULL CHECK(length(target_key)=32), kind INTEGER NOT NULL CHECK(kind BETWEEN 1 AND 6), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,request_key,target_key,kind), FOREIGN KEY(workspace,operation_id,recipient,request_key) REFERENCES chat_delivery_attempts(workspace,operation_id,recipient,request_key)) STRICT, WITHOUT ROWID"; +pub(super) const TABLE_V10: &str = "CREATE TABLE chat_delivery_observations (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, request_key BLOB NOT NULL, target_key BLOB NOT NULL CHECK(length(target_key)=32), kind INTEGER NOT NULL CHECK(kind BETWEEN 1 AND 6), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,request_key,target_key,kind), FOREIGN KEY(workspace,operation_id,recipient,request_key) REFERENCES chat_delivery_attempts(workspace,operation_id,recipient,request_key)) STRICT, WITHOUT ROWID"; +pub(super) const TABLE: &str = "CREATE TABLE artifact_delivery_observations (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL, request_key BLOB NOT NULL, target_key BLOB NOT NULL CHECK(length(target_key)=32), kind INTEGER NOT NULL CHECK(kind BETWEEN 1 AND 6), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key,request_key,target_key,kind), FOREIGN KEY(workspace,operation_id,artifact_key,request_key) REFERENCES artifact_delivery_attempts(workspace,operation_id,artifact_key,request_key)) STRICT, WITHOUT ROWID"; const MAX_OBSERVATIONS: usize = 2 * 16 * 12 * 6; #[derive(Serialize, Deserialize)] @@ -76,7 +77,11 @@ pub(super) async fn protect( crypto: &WorkspaceCrypto, ) -> Result<Protected, OperationError> { let wire = Wire { - version: 1, + version: if report.work().recipient().is_some() { + 1 + } else { + 2 + }, work: WorkRef::new(report.work()), request: report.request_id().as_str().into(), event: report.event_id(), @@ -115,8 +120,8 @@ impl Protected { connection: &mut SqliteConnection, ) -> Result<(), OperationError> { let s = self.scope; - sqlx::query("INSERT INTO chat_delivery_observations(workspace,operation_id,recipient,request_key,target_key,kind,protected) VALUES(?,?,?,?,?,?,?)") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).bind(self.target.as_slice()).bind(self.report.kind().code() as i64).bind(&self.protected).execute(connection).await.map_err(|_|OperationError::StorageFailure)?; + sqlx::query(super::sql(connection,"INSERT INTO chat_delivery_observations(workspace,operation_id,recipient,request_key,target_key,kind,protected) VALUES(?,?,?,?,?,?,?)").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(self.target.as_slice()).bind(self.report.kind().code() as i64).bind(&self.protected).execute(connection).await.map_err(|_|OperationError::StorageFailure)?; Ok(()) } } @@ -129,7 +134,7 @@ impl Observations { crypto: &WorkspaceCrypto, ) -> Result<Self, OperationError> { // Bound keys before fetching or opening any protected observation body. - let rows=sqlx::query("SELECT CASE WHEN length(recipient)=32 THEN recipient END,CASE WHEN length(request_key)=32 THEN request_key END,CASE WHEN length(target_key)=32 THEN target_key END,kind FROM chat_delivery_observations WHERE workspace=? AND operation_id=? ORDER BY recipient,request_key,target_key,kind LIMIT 2305") + let rows=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(recipient)=32 OR (length(recipient)=1 AND hex(recipient)='00') THEN recipient END,CASE WHEN length(request_key)=32 THEN request_key END,CASE WHEN length(target_key)=32 THEN target_key END,kind FROM chat_delivery_observations WHERE workspace=? AND operation_id=? ORDER BY recipient,request_key,target_key,kind LIMIT 2305").await?) .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_all(&mut *connection).await.map_err(bad)?; if rows.len() > MAX_OBSERVATIONS { return Err(OperationError::RecoveryRequired); @@ -146,7 +151,12 @@ impl Observations { .try_into() .map_err(bad) }; - let recipient = key(0)?; + let artifact = row + .try_get::<Option<Vec<u8>>, _>(0) + .map_err(bad)? + .ok_or(OperationError::RecoveryRequired)?; + let target_scope = + radroots_storage::command::SigningTarget::from_key(&artifact).map_err(bad)?; let request = key(1)?; let target = key(2)?; let kind: i64 = row.try_get(3).map_err(bad)?; @@ -157,7 +167,7 @@ impl Observations { .attempts .iter() .find(|attempt| { - attempt.work().recipient().as_bytes() == &recipient + attempt.work().target() == target_scope && codec::request_key(attempt.intent().request_id().as_str()) == request }) .ok_or(OperationError::RecoveryRequired)?; @@ -194,7 +204,7 @@ impl Observations { selected: &super::super::AttachmentInput, operation: radroots_domain::OperationId, ) -> Result<(), OperationError> { - let count:i64=sqlx::query_scalar("SELECT count(*) FROM (SELECT 1 FROM chat_delivery_observations WHERE workspace=? AND operation_id=? LIMIT 2305)") + let count:i64=sqlx::query_scalar(super::sql(connection,"SELECT count(*) FROM (SELECT 1 FROM chat_delivery_observations WHERE workspace=? AND operation_id=? LIMIT 2305)").await?) .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).fetch_one(&mut *connection).await.map_err(bad)?; if count != self.facts.len() as i64 { return Err(OperationError::RecoveryRequired); @@ -214,7 +224,12 @@ fn decode( target: [u8; 32], kind: u8, ) -> Result<DeliveryObservation, OperationError> { - if wire.version != 1 + if wire.version + != if attempt.work().recipient().is_some() { + 1 + } else { + 2 + } || wire.work != WorkRef::new(attempt.work()) || wire.request != attempt.intent().request_id().as_str() || wire.event != attempt.intent().event_id() @@ -236,6 +251,6 @@ async fn read_body( target: [u8; 32], kind: u8, ) -> Result<Vec<u8>, OperationError> { - sqlx::query_scalar::<_,Option<Vec<u8>>>("SELECT CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_observations WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? AND target_key=? AND kind=?") - .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.recipient.as_bytes().as_slice()).bind(s.request.as_slice()).bind(target.as_slice()).bind(kind as i64).fetch_optional(connection).await.map_err(bad)?.flatten().ok_or(OperationError::RecoveryRequired) + sqlx::query_scalar::<_,Option<Vec<u8>>>(super::sql(connection,"SELECT CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_observations WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? AND target_key=? AND kind=?").await?) + .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(target.as_slice()).bind(kind as i64).fetch_optional(connection).await.map_err(bad)?.flatten().ok_or(OperationError::RecoveryRequired) } diff --git a/crates/storage_sqlite/src/workspace/delivery/observation_operations.rs b/crates/storage_sqlite/src/workspace/delivery/observation_operations.rs @@ -9,8 +9,10 @@ use super::{ graph::Graph, observation::{self, Observations}, }; -use radroots_domain::{CommandDigest, OperationId, PublicKey}; -use radroots_storage::command::{DeliveryObservation, DeliveryObservationOutcome, OperationError}; +use radroots_domain::{CommandDigest, OperationId}; +use radroots_storage::command::{ + DeliveryObservation, DeliveryObservationOutcome, OperationError, SigningTarget, +}; use radroots_transport::sink::DeliveryRequestId; use sqlx::Connection; @@ -41,12 +43,21 @@ impl Journal<'_> { self.crypto, ) .await?; + let public = super::super::listing_installation::Records::read( + self.connection, + self.selected, + e.operation_id(), + &original, + self.crypto, + ) + .await?; let deliveries = Graph::read( self.connection, self.selected, e.operation_id(), &original, &installed, + &public, self.crypto, ) .await?; @@ -106,6 +117,9 @@ impl Journal<'_> { installed .unchanged(&mut transaction, self.selected, e.operation_id()) .await?; + public + .unchanged(&mut transaction, self.selected, e.operation_id()) + .await?; deliveries .unchanged(&mut transaction, self.selected, e.operation_id()) .await?; @@ -142,7 +156,7 @@ impl Journal<'_> { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> Result<Vec<DeliveryObservation>, OperationError> { @@ -172,12 +186,21 @@ impl Journal<'_> { self.crypto, ) .await?; + let public = super::super::listing_installation::Records::read( + self.connection, + self.selected, + operation, + &original, + self.crypto, + ) + .await?; let deliveries = Graph::read( self.connection, self.selected, operation, &original, &installed, + &public, self.crypto, ) .await?; @@ -212,6 +235,9 @@ impl Journal<'_> { installed .unchanged(&mut transaction, self.selected, operation) .await?; + public + .unchanged(&mut transaction, self.selected, operation) + .await?; deliveries .unchanged(&mut transaction, self.selected, operation) .await?; @@ -229,7 +255,7 @@ impl Journal<'_> { Ok(observations .reports .into_iter() - .filter(|value| value.request_id() == &request && value.work().recipient() == recipient) + .filter(|value| value.request_id() == &request && value.work().target() == target) .collect()) } } diff --git a/crates/storage_sqlite/src/workspace/delivery/observation_tests.rs b/crates/storage_sqlite/src/workspace/delivery/observation_tests.rs @@ -67,7 +67,7 @@ mod cases { .unwrap(); let wire: Wire = serde_json::from_slice(&serde_json::to_vec(&changed).unwrap()).unwrap(); assert!(decode(wire, &data.report, target, kind).is_err()); - sqlx::query("UPDATE chat_delivery_observations SET protected=zeroblob(262145)") + sqlx::query("UPDATE artifact_delivery_observations SET protected=zeroblob(262145)") .execute(&mut data.database) .await .unwrap(); @@ -76,7 +76,7 @@ mod cases { .await .is_err() ); - sqlx::query("DELETE FROM chat_delivery_observations") + sqlx::query("DELETE FROM artifact_delivery_observations") .execute(&mut data.database) .await .unwrap(); diff --git a/crates/storage_sqlite/src/workspace/delivery/operations.rs b/crates/storage_sqlite/src/workspace/delivery/operations.rs @@ -6,10 +6,10 @@ use super::super::{ }; use super::{codec, graph::Graph, observation::Observations}; use nostr::JsonUtil; -use radroots_domain::{CommandDigest, OperationId, PublicKey, TransactionId}; +use radroots_domain::{CommandDigest, OperationId, TransactionId}; use radroots_storage::command::{ CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, - EnvelopeCandidate, OperationError, PublicationWork, + EnvelopeCandidate, OperationError, PublicationArtifact, PublicationWork, SigningTarget, }; use radroots_transport::sink::DeliveryRequestId; use sha2::{Digest, Sha256}; @@ -69,13 +69,24 @@ fn contains_original( } Ok(()) } -fn work(records: &Records, requested: PublicationWork) -> Result<PublicationWork, OperationError> { - let actual = records - .work - .iter() - .find(|value| value.report.recipient() == requested.recipient()) - .ok_or(OperationError::InvalidEvidence)? - .report; +fn work( + records: &Records, + public: &super::super::listing_installation::Records, + requested: PublicationArtifact, +) -> Result<PublicationArtifact, OperationError> { + let actual = match requested { + PublicationArtifact::Private(v) => PublicationArtifact::Private( + records + .work + .iter() + .find(|r| r.report.recipient() == v.recipient()) + .ok_or(OperationError::InvalidEvidence)? + .report, + ), + PublicationArtifact::Public(_) => { + PublicationArtifact::Public(public.work().ok_or(OperationError::InvalidEvidence)?) + } + }; if actual != requested { return Err(OperationError::InvalidEvidence); } @@ -115,18 +126,27 @@ impl Journal<'_> { self.crypto, ) .await?; - let actual = work(&installed, supplied)?; + let public = super::super::listing_installation::Records::read( + self.connection, + self.selected, + evidence.operation_id(), + &original, + self.crypto, + ) + .await?; + let actual = work(&installed, &public, supplied)?; let mut deliveries = Graph::read( self.connection, self.selected, evidence.operation_id(), &original, &installed, + &public, self.crypto, ) .await?; let existing = deliveries.attempts.iter().position(|value| { - Some(value.work().recipient()) == evidence.target().recipient() + value.work().target() == evidence.target() && value.intent().request_id() == request.intent().request_id() }); let observations = Observations::read( @@ -142,7 +162,8 @@ impl Journal<'_> { if value.work() != actual || value.intent().digest() != request.intent().digest() || candidate.as_ref().is_some_and(|candidate| { - candidate.work() != actual || candidate.raw_json() != value.raw_json() + PublicationArtifact::Private(candidate.work()) != actual + || candidate.raw_json() != value.raw_json() }) { return Err(OperationError::IdempotencyConflict); @@ -160,8 +181,9 @@ impl Journal<'_> { let bound = original .bound_plan() .ok_or(OperationError::RecoveryRequired)?; - deliveries.authorize_routes(bound, evidence.recipient()?)?; - let ordinals = deliveries.ordinals(evidence.recipient()?, request.intent())?; + super::require_target(self.connection, actual.target()).await?; + deliveries.authorize_routes(bound, actual.target())?; + let ordinals = deliveries.ordinals(actual.target(), request.intent())?; if current.observed_at() < actual.queued_at() || deliveries .attempts @@ -178,15 +200,27 @@ impl Journal<'_> { { return Err(OperationError::DeadlineExceeded); } - let raw = match &candidate { - Some(candidate) => { + let raw = match (actual, &candidate) { + (PublicationArtifact::Public(_), None) => { + let source = original + .obtained_artifact(SigningTarget::PublicEvent) + .ok_or(OperationError::InvalidEvidence)?; + if request.intent().event_id() != source.event_id() { + return Err(OperationError::InvalidEvidence); + } + Zeroizing::new(String::from(source.raw_json())) + } + (PublicationArtifact::Public(_), Some(_)) => { + return Err(OperationError::InvalidEvidence); + } + (PublicationArtifact::Private(private), Some(candidate)) => { if candidate.event_id() != request.intent().event_id() { return Err(OperationError::InvalidEvidence); } - contains_original(candidate, actual, &original)?; + contains_original(candidate, private, &original)?; Zeroizing::new(String::from(candidate.raw_json())) } - None => { + (PublicationArtifact::Private(_), None) => { let retained = deliveries .attempts .iter() @@ -253,6 +287,9 @@ impl Journal<'_> { installed .unchanged(&mut transaction, self.selected, evidence.operation_id()) .await?; + public + .unchanged(&mut transaction, self.selected, evidence.operation_id()) + .await?; deliveries .unchanged(&mut transaction, self.selected, evidence.operation_id()) .await?; @@ -317,7 +354,7 @@ impl Journal<'_> { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> Result<Option<DeliveryAttempt>, OperationError> { @@ -347,12 +384,21 @@ impl Journal<'_> { self.crypto, ) .await?; + let public = super::super::listing_installation::Records::read( + self.connection, + self.selected, + operation, + &original, + self.crypto, + ) + .await?; let mut deliveries = Graph::read( self.connection, self.selected, operation, &original, &installed, + &public, self.crypto, ) .await?; @@ -387,6 +433,9 @@ impl Journal<'_> { installed .unchanged(&mut transaction, self.selected, operation) .await?; + public + .unchanged(&mut transaction, self.selected, operation) + .await?; deliveries .unchanged(&mut transaction, self.selected, operation) .await?; @@ -405,7 +454,7 @@ impl Journal<'_> { .attempts .iter() .position(|value| { - value.work().recipient() == recipient && value.intent().request_id() == &request + value.work().target() == target && value.intent().request_id() == &request }) .map(|index| deliveries.attempts.remove(index))) } diff --git a/crates/storage_sqlite/src/workspace/listing.rs b/crates/storage_sqlite/src/workspace/listing.rs @@ -145,7 +145,7 @@ pub(super) async fn current(connection: &mut SqliteConnection) -> Result<bool, O .map_err(|_| OperationError::RecoveryRequired)?; match version { 7..=9 => Ok(false), - 10 => Ok(true), + 10 | 11 => Ok(true), _ => Err(OperationError::RecoveryRequired), } } diff --git a/crates/storage_sqlite/src/workspace/listing_installation.rs b/crates/storage_sqlite/src/workspace/listing_installation.rs @@ -24,7 +24,7 @@ pub(super) const WORK: &str = "CREATE TABLE public_publication_work (workspace B pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX listing_installation_transaction_identity ON listing_installations(workspace,transaction_id)"; #[derive(Serialize, Deserialize, Eq, PartialEq)] #[serde(deny_unknown_fields)] -struct PublicEvidenceRef { +pub(super) struct PublicEvidenceRef { workspace: WorkspaceId, operation: OperationId, command: CommandDigest, @@ -35,7 +35,7 @@ struct PublicEvidenceRef { observed_at: Option<u64>, } impl PublicEvidenceRef { - fn new(e: EvidenceReceipt) -> Self { + pub(super) fn new(e: EvidenceReceipt) -> Self { Self { workspace: e.workspace_id(), operation: e.operation_id(), diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs @@ -31,7 +31,7 @@ pub use radroots_storage::workspace::{ WorkspaceError, }; -use radroots_domain::{ExecutorId, GrantId, PublicKey, WorkspaceId}; +use radroots_domain::{ExecutorId, GrantId, WorkspaceId}; use radroots_storage::workspace::WorkspaceStore; use radroots_transport::BoxFuture; use std::{path::Path, sync::Arc}; @@ -174,7 +174,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { binding: WorkspaceBinding, operation: radroots_domain::OperationId, digest: radroots_domain::CommandDigest, - recipient: PublicKey, + target: radroots_storage::command::SigningTarget, request: radroots_transport::sink::DeliveryRequestId, proof: AttachmentProof, ) -> BoxFuture< @@ -186,7 +186,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { > { Box::pin( self.worker - .query_delivery_observations(binding, operation, digest, recipient, request, proof), + .query_delivery_observations(binding, operation, digest, target, request, proof), ) } fn prepare_delivery_attempt<'a>( @@ -208,7 +208,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { binding: WorkspaceBinding, operation: radroots_domain::OperationId, digest: radroots_domain::CommandDigest, - recipient: PublicKey, + target: radroots_storage::command::SigningTarget, request: radroots_transport::sink::DeliveryRequestId, proof: AttachmentProof, ) -> BoxFuture< @@ -220,7 +220,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { > { Box::pin( self.worker - .query_delivery(binding, operation, digest, recipient, request, proof), + .query_delivery(binding, operation, digest, target, request, proof), ) } fn install_transition_and_outbox( diff --git a/crates/storage_sqlite/src/workspace/snapshot.rs b/crates/storage_sqlite/src/workspace/snapshot.rs @@ -31,6 +31,12 @@ pub(super) struct RetainedGraph { artifacts: Vec<SeenArtifact>, } impl RetainedGraph { + pub(super) fn obtained_artifact(&self, target: SigningTarget) -> Option<&ArtifactEvidence> { + self.artifacts + .iter() + .find(|v| v.report.target() == target) + .and_then(|v| v.obtained.as_ref()) + } pub(super) fn obtained(&self, recipient: PublicKey) -> Option<&ArtifactEvidence> { self.artifacts .iter() @@ -253,8 +259,10 @@ impl RetainedFacts { connection, selected, operation, &graph, crypto, ) .await?; - let deliveries = - DeliveryGraph::read(connection, selected, operation, &graph, &records, crypto).await?; + let deliveries = DeliveryGraph::read( + connection, selected, operation, &graph, &records, &listing, crypto, + ) + .await?; let observations = Observations::read(connection, &deliveries, selected, operation, crypto).await?; Ok(Self { diff --git a/crates/storage_sqlite/src/workspace/tests/issuance_records.rs b/crates/storage_sqlite/src/workspace/tests/issuance_records.rs @@ -126,6 +126,157 @@ pub(in crate::workspace) async fn delivery_data() -> DeliveryData { report, } } + +/// Codec-only structural public reports. This fixture does not claim that the +/// database authorized public T0/S/T2/D; actual facade tests cover that path. +#[cfg(test)] +pub(in crate::workspace) async fn public_delivery_data() -> DeliveryData { + use radroots_domain::{ActorRef, ActorRole, IssuanceWindow, Sequence}; + use radroots_protocol::{listing::PublicSigningPlan, plan::SigningReplay}; + use radroots_storage::{ + command::{ + DeliveryAttempt, DeliveryIntent, EvidenceReceipt, ListingInstallation, + PreparedOperation, PublicPublicationWork, SigningTarget, + }, + workspace::{LocalOutboxScope, WorkspaceBinding}, + }; + let mut data = delivery_data().await; + let selected = data.selection(); + let time = UnixSeconds::new(100).unwrap(); + let binding = WorkspaceBinding::from_authenticated_host( + selected.clone(), + LocalOutboxScope::NewSellerOutbox, + ActorRef::new( + participant(), + ActorRole::Seller, + None, + Some(selected.grant_id()), + ), + "codec-only", + Sequence::new(1).unwrap(), + UnixSeconds::new(200).unwrap(), + time, + ) + .unwrap(); + let context = CommandContextData::new( + OperationId::from_bytes([62; 32]), + binding.actor(), + selected.workspace_id(), + selected.authority(), + selected.route_digest(), + None, + None, + UnixSeconds::new(150).unwrap(), + None, + ) + .unwrap(); + let wire = json!({"type":"listing.publish","context":context,"input":{ + "id":"01".repeat(16),"title":"Codec public listing","summary":"Quote required", + "description_markdown":"Public terms","published_at":"100", + "profile":{"profile":"radroots.listing","version":1,"state":"active", + "product":{"name":"Carrots","description":"Public description","producer":null,"origin_summary":null}, + "default_option":"02".repeat(32),"options":[{"id":"02".repeat(32),"label":"Bunch", + "unit":{"type":"package","label":"bunch","contents":{"type":"unspecified"}}, + "increment":"1","minimum":"1","price":{"type":"quote_required"}, + "supply":{"type":"available","amount":"10"},"lead_seconds":"0"}], + "fulfillment":{"modes":["pickup"],"area":"Example","lead_seconds":"0"},"authority":null,"media":[]}}}); + let request = + AdmissionRequest::from_protected_wire(binding, &serde_json::to_vec(&wire).unwrap()) + .unwrap(); + let plan = PublicSigningPlan::capture( + request.command().listing().unwrap(), + time, + &["wss://route.example/".into()], + SigningReplay::NonReplayable, + ) + .unwrap(); + let prepared = PreparedOperation::from_committed_store( + request, + TransactionId::from_bytes([80; 32]), + Sequence::new(1).unwrap(), + IssuanceWindow::new(time, UnixSeconds::new(150).unwrap()).unwrap(), + ) + .unwrap(); + let bound = BoundSigningPlan::from_committed_store( + prepared, + plan, + TransactionId::from_bytes([81; 32]), + time, + ) + .unwrap(); + let attempt = SigningAttempt::from_committed_store( + bound, + SigningTarget::PublicEvent, + SigningAttemptId::from_bytes([82; 32]), + TransactionId::from_bytes([83; 32]), + time, + ) + .unwrap(); + let fields = attempt + .bound_plan() + .plan() + .listing() + .unwrap() + .event() + .fields(); + let mut scalar = [0; 32]; + scalar[31] = 1; + let keys = nostr::Keys::new(nostr::SecretKey::from_slice(&scalar).unwrap()); + let raw = nostr::UnsignedEvent { + id: None, + pubkey: keys.public_key(), + created_at: nostr::Timestamp::from_secs(fields.created_at), + kind: nostr::Kind::Custom(fields.kind.try_into().unwrap()), + tags: nostr::Tags::from_list( + fields + .tags + .iter() + .map(|v| nostr::Tag::parse(v).unwrap()) + .collect(), + ), + content: fields.content.into(), + } + .sign_with_keys(&keys) + .unwrap() + .as_json(); + let evidence = ArtifactEvidence::verify(&attempt, &raw, None).unwrap(); + let receipt = + EvidenceReceipt::from_committed_store(&evidence, TransactionId::from_bytes([84; 32])); + let installed = ListingInstallation::from_committed_store( + attempt.bound_plan(), + receipt, + TransactionId::from_bytes([85; 32]), + time, + ) + .unwrap(); + let work = PublicPublicationWork::from_committed_store( + attempt.bound_plan(), + installed, + receipt, + TransactionId::from_bytes([86; 32]), + time, + ) + .unwrap(); + let intent = DeliveryIntent::public( + &"03".repeat(32), + receipt.event_id(), + data.report.intent().targets(), + data.report.intent().policy(), + data.report.intent().deadline_unix_ms(), + ) + .unwrap(); + data.report = DeliveryAttempt::from_store_report( + work, + intent, + &raw, + TransactionId::from_bytes([87; 32]), + time, + vec![1], + ) + .unwrap(); + data +} + impl Issued { async fn new() -> Self { let fixture = CryptoFixture::new(); diff --git a/crates/storage_sqlite/src/workspace/tests/mod.rs b/crates/storage_sqlite/src/workspace/tests/mod.rs @@ -1,7 +1,7 @@ use super::*; use radroots_domain::{ - ActorRole, AuthorityRef, CheckpointDigest, CheckpointRef, Coverage, Generation, RouteDigest, - Sequence, UnixSeconds, + ActorRole, AuthorityRef, CheckpointDigest, CheckpointRef, Coverage, Generation, PublicKey, + RouteDigest, Sequence, UnixSeconds, }; pub(super) mod issuance_records; mod operation_records; @@ -686,7 +686,7 @@ async fn existing_database_rejects_corrupt_version_missing_grant_and_oversized_r WorkspaceError::RecoveryRequired }; let statement = match fault { - 0 => "PRAGMA user_version=11", + 0 => "PRAGMA user_version=12", 1 => "DELETE FROM workspace_grant", 2 => "UPDATE workspace_grant SET grant_id=zeroblob(31)", 3 => "UPDATE workspace_grant SET protected=zeroblob(0)", @@ -732,7 +732,7 @@ async fn existing_database_rejects_corrupt_version_missing_grant_and_oversized_r .fetch_one(&mut connection) .await .unwrap(); - assert_eq!(version, if fault == 0 { 11 } else { 10 }); + assert_eq!(version, if fault == 0 { 12 } else { 11 }); assert_eq!(rows, if fault == 1 { 0 } else { 1 }); if let Some(expected) = retained_protected { let actual: Vec<u8> = sqlx::query_scalar("SELECT protected FROM workspace_grant") diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -3,14 +3,14 @@ use super::{ WorkspaceError, admission::Journal, attempt, delivery, evidence, fs::Namespace, installation, listing, operation, plan, record::GrantRecord, }; -use radroots_domain::{CommandDigest, OperationId, PublicKey}; +use radroots_domain::{CommandDigest, OperationId}; use radroots_storage::command::{ AdmissionOutcome, AdmissionRequest, ArtifactEvidence, BoundSigningPlan, CapturedArtifact, CapturedSigningPlan, ClaimAttemptOutcome, ClaimAttemptRequest, CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryObservation, DeliveryObservationOutcome, EnvelopeCandidate, EvidenceCaptureOutcome, InstallationOutcome, InstallationRequest, OperationError, OperationSnapshot, PlanBindingOutcome, PreparedOperation, - SigningAttempt, + SigningAttempt, SigningTarget, }; use radroots_transport::sink::DeliveryRequestId; use sqlx::{ @@ -46,7 +46,7 @@ enum Job { Box<WorkspaceBinding>, OperationId, CommandDigest, - PublicKey, + SigningTarget, DeliveryRequestId, AttachmentProof, Reply<Vec<DeliveryObservation>, OperationError>, @@ -61,7 +61,7 @@ enum Job { Box<WorkspaceBinding>, OperationId, CommandDigest, - PublicKey, + SigningTarget, DeliveryRequestId, AttachmentProof, Reply<Option<DeliveryAttempt>, OperationError>, @@ -665,7 +665,7 @@ impl Handle { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> Result<Vec<DeliveryObservation>, OperationError> { @@ -674,7 +674,7 @@ impl Handle { Box::new(binding), operation, digest, - recipient, + target, request, proof, reply, @@ -686,7 +686,7 @@ impl Handle { binding: WorkspaceBinding, operation: OperationId, digest: CommandDigest, - recipient: PublicKey, + target: SigningTarget, request: DeliveryRequestId, proof: AttachmentProof, ) -> Result<Option<DeliveryAttempt>, OperationError> { @@ -695,7 +695,7 @@ impl Handle { Box::new(binding), operation, digest, - recipient, + target, request, proof, reply, @@ -1018,7 +1018,7 @@ pub(super) async fn initialize( .await .map_err(|_| WorkspaceError::StorageFailure)?; } - sqlx::query("PRAGMA user_version=10") + sqlx::query("PRAGMA user_version=11") .execute(&mut *transaction) .await .map_err(|_| WorkspaceError::StorageFailure)?; @@ -1040,22 +1040,27 @@ pub(super) async fn initialize( .fetch_one(&mut *connection) .await .map_err(|_| WorkspaceError::RecoveryRequired)?; - if !matches!(version, 7..=10) { + if !matches!(version, 7..=11) { return Err(WorkspaceError::RecoveryRequired); } let catalog_sql = "SELECT CASE WHEN count(*)=20 AND sum(CASE WHEN type='table' AND name='workspace_grant' AND tbl_name='workspace_grant' AND sql=? THEN 1 WHEN type='table' AND name='operations' AND tbl_name='operations' AND sql=? THEN 1 WHEN type='table' AND name='signing_plans' AND tbl_name='signing_plans' AND sql=? THEN 1 WHEN type='table' AND name='signing_plan_parts' AND tbl_name='signing_plan_parts' AND sql=? THEN 1 WHEN type='table' AND name='signing_attempts' AND tbl_name='signing_attempts' AND sql=? THEN 1 WHEN type='index' AND name='signing_attempt_identity' AND tbl_name='signing_attempts' AND sql=? THEN 1 WHEN type='index' AND name='signing_attempt_transaction_identity' AND tbl_name='signing_attempts' AND sql=? THEN 1 WHEN type='table' AND name='seal_evidence' AND tbl_name='seal_evidence' AND sql=? THEN 1 WHEN type='table' AND name='seal_evidence_parts' AND tbl_name='seal_evidence_parts' AND sql=? THEN 1 WHEN type='index' AND name='seal_evidence_transaction_identity' AND tbl_name='seal_evidence' AND sql=? THEN 1 WHEN type='index' AND name='operation_transaction_identity' AND tbl_name='operations' AND sql=? THEN 1 WHEN type='table' AND name='chat_messages' AND tbl_name='chat_messages' AND sql=? THEN 1 WHEN type='index' AND name='chat_message_operation_identity' AND tbl_name='chat_messages' AND sql=? THEN 1 WHEN type='index' AND name='chat_message_transaction_identity' AND tbl_name='chat_messages' AND sql=? THEN 1 WHEN type='index' AND name='chat_message_thread' AND tbl_name='chat_messages' AND sql=? THEN 1 WHEN type='table' AND name='chat_publication_work' AND tbl_name='chat_publication_work' AND sql=? THEN 1 WHEN type='table' AND name='chat_delivery_attempts' AND tbl_name='chat_delivery_attempts' AND sql=? THEN 1 WHEN type='table' AND name='chat_delivery_parts' AND tbl_name='chat_delivery_parts' AND sql=? THEN 1 WHEN type='index' AND name='chat_delivery_transaction_identity' AND tbl_name='chat_delivery_attempts' AND sql=? THEN 1 WHEN type='table' AND name='chat_delivery_observations' AND tbl_name='chat_delivery_observations' AND sql=? THEN 1 ELSE 0 END)=20 THEN 1 ELSE 0 END FROM sqlite_schema"; - let catalog_sql = if matches!(version, 9 | 10) { + let catalog_sql = if matches!(version, 9..=11) { catalog_sql.replace("seal_evidence", "artifact_evidence") } else { catalog_sql.to_owned() }; - let catalog_sql = if version == 10 { + let catalog_sql = if matches!(version, 10 | 11) { catalog_sql.replace("count(*)=20", "count(*)=25").replace("END)=20", "END)=25").replace("WHEN type='table' AND name='workspace_grant'", "WHEN type='table' AND name='listing_creations' AND tbl_name='listing_creations' AND sql=? THEN 1 WHEN type='index' AND name='listing_coordinate_identity' AND tbl_name='listing_creations' AND sql=? THEN 1 WHEN type='table' AND name='listing_installations' AND tbl_name='listing_installations' AND sql=? THEN 1 WHEN type='index' AND name='listing_installation_transaction_identity' AND tbl_name='listing_installations' AND sql=? THEN 1 WHEN type='table' AND name='public_publication_work' AND tbl_name='public_publication_work' AND sql=? THEN 1 WHEN type='table' AND name='workspace_grant'") } else { catalog_sql }; + let catalog_sql = if version == 11 { + catalog_sql.replace("chat_delivery", "artifact_delivery") + } else { + catalog_sql + }; let catalog_query = sqlx::query_scalar(sqlx::AssertSqlSafe(catalog_sql)); - let catalog_query = if version == 10 { + let catalog_query = if matches!(version, 10 | 11) { catalog_query .bind(listing::CREATIONS) .bind(listing::COORDINATE_INDEX) @@ -1074,24 +1079,24 @@ pub(super) async fn initialize( }) .bind(plan::TABLE) .bind(plan::PARTS) - .bind(if matches!(version, 9 | 10) { + .bind(if matches!(version, 9..=11) { attempt::TABLE } else { attempt::TABLE_V8 }) .bind(attempt::ID_INDEX) .bind(attempt::TX_INDEX) - .bind(if matches!(version, 9 | 10) { + .bind(if matches!(version, 9..=11) { evidence::TABLE } else { evidence::TABLE_V8 }) - .bind(if matches!(version, 9 | 10) { + .bind(if matches!(version, 9..=11) { evidence::PARTS } else { evidence::PARTS_V8 }) - .bind(if matches!(version, 9 | 10) { + .bind(if matches!(version, 9..=11) { evidence::TX_INDEX } else { evidence::TX_INDEX_V8 @@ -1101,15 +1106,31 @@ pub(super) async fn initialize( .bind(installation::OP_INDEX) .bind(installation::TX_INDEX) .bind(installation::THREAD_INDEX) - .bind(if matches!(version, 9 | 10) { + .bind(if matches!(version, 9..=11) { installation::WORK } else { installation::WORK_V8 }) - .bind(delivery::TABLE) - .bind(delivery::PARTS) - .bind(delivery::TX_INDEX) - .bind(delivery::OBSERVATIONS) + .bind(if version == 11 { + delivery::TABLE + } else { + delivery::TABLE_V10 + }) + .bind(if version == 11 { + delivery::PARTS + } else { + delivery::PARTS_V10 + }) + .bind(if version == 11 { + delivery::TX_INDEX + } else { + delivery::TX_INDEX_V10 + }) + .bind(if version == 11 { + delivery::OBSERVATIONS + } else { + delivery::OBSERVATIONS_V10 + }) .fetch_one(&mut *connection) .await .map_err(|_| WorkspaceError::RecoveryRequired)?; diff --git a/crates/storage_sqlite/tests/support/legacy_delivery_catalog.rs b/crates/storage_sqlite/tests/support/legacy_delivery_catalog.rs @@ -0,0 +1,83 @@ +use sqlx::SqliteConnection; + +// Synthetic exact predecessor catalog, never a claim that an old binary ran. +pub(super) async fn retain_legacy_delivery_catalog(db: &mut SqliteConnection) { + use sqlx::Row; + let public: i64 = sqlx::query_scalar( + "SELECT count(*) FROM artifact_delivery_attempts WHERE length(artifact_key)!=32", + ) + .fetch_one(&mut *db) + .await + .unwrap(); + assert_eq!(public, 0); + let rows=sqlx::query("SELECT name,sql FROM sqlite_schema WHERE name IN ('artifact_delivery_attempts','artifact_delivery_parts','artifact_delivery_observations','artifact_delivery_transaction_identity')").fetch_all(&mut *db).await.unwrap(); + let definitions = rows + .into_iter() + .map(|row| { + let name: String = row.get(0); + let ddl: String = row.get(1); + let ddl = ddl + .replace("artifact_delivery", "chat_delivery") + .replace("artifact_key", "recipient") + .replace( + "CHECK(length(recipient)=32 OR (length(recipient)=1 AND hex(recipient)='00'))", + "CHECK(length(recipient)=32)", + ) + .replace( + "REFERENCES artifact_evidence(workspace,operation_id,recipient)", + "REFERENCES chat_publication_work(workspace,operation_id,recipient)", + ); + (name, ddl) + }) + .collect::<std::collections::BTreeMap<_, _>>(); + for table in [ + "artifact_delivery_attempts", + "artifact_delivery_parts", + "artifact_delivery_observations", + ] { + sqlx::query(sqlx::AssertSqlSafe(format!( + "CREATE TEMP TABLE retained_{table} AS SELECT * FROM {table}" + ))) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "artifact_delivery_observations", + "artifact_delivery_parts", + "artifact_delivery_attempts", + ] { + sqlx::query(sqlx::AssertSqlSafe(format!("DROP TABLE {table}"))) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "artifact_delivery_attempts", + "artifact_delivery_transaction_identity", + "artifact_delivery_parts", + "artifact_delivery_observations", + ] { + sqlx::query(sqlx::AssertSqlSafe(definitions[table].clone())) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "artifact_delivery_attempts", + "artifact_delivery_parts", + "artifact_delivery_observations", + ] { + let legacy = table.replace("artifact_delivery", "chat_delivery"); + sqlx::query(sqlx::AssertSqlSafe(format!( + "INSERT INTO {legacy} SELECT * FROM retained_{table}" + ))) + .execute(&mut *db) + .await + .unwrap(); + sqlx::query(sqlx::AssertSqlSafe(format!("DROP TABLE retained_{table}"))) + .execute(&mut *db) + .await + .unwrap(); + } +} diff --git a/crates/storage_sqlite/tests/support/public_admission.rs b/crates/storage_sqlite/tests/support/public_admission.rs @@ -1489,6 +1489,157 @@ mod public_issuance { ); reopened.close().await.unwrap(); } + + #[tokio::test] + async fn exact_generation_ten_retains_public_installation_but_refuses_fresh_public_delivery() { + use radroots_storage::command::{DeliveryAttemptRequest, DeliveryIntent}; + use radroots_transport::{ + Target, TargetSet, + policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, + }; + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create_scoped(200, true).await; + let (prepared, digest, evidence) = + signed(&fixture, &store, &binding, &input, &proof, 187).await; + let installation = installed( + store + .install_transition_and_outbox( + install_request(&binding, &prepared, digest), + copy(&proof), + ) + .await + .unwrap(), + ); + let original = store + .operation_snapshot( + binding.clone(), + prepared.identity().operation_id(), + None, + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + let work = original.public_publications()[0]; + let checkpoint = original.checkpoint_digest(); + store.close().await.unwrap(); + let mut db = fixture.database().await; + retain_legacy_delivery_catalog(&mut db).await; + sqlx::query("PRAGMA user_version=10") + .execute(&mut db) + .await + .unwrap(); + let catalog: Vec<(String, String)> = sqlx::query_as( + "SELECT name,sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%' ORDER BY name", + ) + .fetch_all(&mut db) + .await + .unwrap(); + db.close().await.unwrap(); + let reopened = fixture.reopen(input).await; + let actual = reopened + .operation_snapshot( + binding.clone(), + prepared.identity().operation_id(), + None, + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(actual.checkpoint_digest(), checkpoint); + assert_eq!(actual.listing_installation(), Some(installation)); + assert_eq!(actual.public_publications(), &[work]); + assert_eq!( + reopened + .obtained_evidence(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap() + .unwrap() + .evidence() + .raw_json(), + evidence.raw_json() + ); + let targets = TargetSet::new(vec![ + Target::nostr_relay("wss://public-signature.fixture.example/a").unwrap(), + ]) + .unwrap(); + let delivery_request = DeliveryAttemptRequest::new( + binding.clone(), + work, + DeliveryIntent::public( + &"18".repeat(32), + work.evidence().event_id(), + &targets, + &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + core::num::NonZeroU64::new(140_000).unwrap(), + ) + .unwrap(), + ) + .unwrap(); + assert!(matches!( + reopened + .prepare_delivery_attempt(delivery_request, copy(&proof), None) + .await, + Err(OperationError::UnsupportedOperation) + )); + let after = reopened + .operation_snapshot( + binding.clone(), + prepared.identity().operation_id(), + None, + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(after.checkpoint_digest(), checkpoint); + assert!(after.delivery_attempts().is_empty()); + assert_eq!( + installed( + reopened + .install_transition_and_outbox( + install_request(&binding, &prepared, digest), + copy(&proof) + ) + .await + .unwrap() + ), + installation + ); + committed( + reopened + .admit_command_and_hold( + request( + &binding, + 188, + "generation10 private continuation", + "private", + ), + copy(&proof), + ) + .await + .unwrap(), + ); + reopened.close().await.unwrap(); + let mut db = fixture.database().await; + let retained: Vec<(String, String)> = sqlx::query_as( + "SELECT name,sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%' ORDER BY name", + ) + .fetch_all(&mut db) + .await + .unwrap(); + assert_eq!(retained, catalog); + assert_eq!( + sqlx::query_scalar::<_, i64>("PRAGMA user_version") + .fetch_one(&mut db) + .await + .unwrap(), + 10 + ); + db.close().await.unwrap(); + } + #[tokio::test] async fn exact_generation_nine_preserves_public_s_and_refuses_unfenced_new_effects() { let fixture = Fixture::new(); @@ -1497,6 +1648,7 @@ mod public_issuance { signed(&fixture, &store, &binding, &input, &proof, 177).await; store.close().await.unwrap(); let mut db = fixture.database().await; + retain_legacy_delivery_catalog(&mut db).await; sqlx::raw_sql("DROP TABLE public_publication_work; DROP TABLE listing_installations; DROP TABLE listing_creations; PRAGMA user_version=9").execute(&mut db).await.unwrap(); db.close().await.unwrap(); let reopened = fixture.reopen(input).await; @@ -1698,7 +1850,12 @@ mod public_issuance { } } +#[path = "legacy_delivery_catalog.rs"] +mod legacy_delivery_catalog; +use legacy_delivery_catalog::retain_legacy_delivery_catalog; + pub(super) async fn retain_legacy_issuance_catalog(db: &mut SqliteConnection) { + retain_legacy_delivery_catalog(db).await; sqlx::raw_sql("DROP TABLE public_publication_work; DROP TABLE listing_installations; DROP TABLE listing_creations").execute(&mut *db).await.unwrap(); use sqlx::Row; let rows=sqlx::query("SELECT name,sql FROM sqlite_schema WHERE name IN ('signing_attempts','signing_attempt_identity','signing_attempt_transaction_identity','artifact_evidence','artifact_evidence_transaction_identity','artifact_evidence_parts','chat_publication_work')").fetch_all(&mut *db).await.unwrap();