commit 9e9ce7d9f38d20f419a494d6083463a97a3726ff parent 7e81581f79cdff774ea51cb01bd9c07fe1290f9a Author: triesap <tyson@radroots.org> Date: Tue, 20 Oct 2026 14:29:14 +0000 execution: Capture public signatures through the shared journal - Select typed public and private artifacts without a synthetic public recipient - Retain public claims and exact verified evidence while preserving private recovery - Carry typed listing fields through the existing qualified exact-signing port - Verify native and browser workflows, seven API surfaces and dependency guards Diffstat:
76 files changed, 2081 insertions(+), 699 deletions(-)
diff --git a/contracts/api_baselines/radroots_protocol.txt b/contracts/api_baselines/radroots_protocol.txt @@ -540,6 +540,8 @@ impl core::fmt::Debug for radroots_protocol::listing::PublishInput pub fn radroots_protocol::listing::PublishInput::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub const radroots_protocol::listing::LISTING_EVENT_MAX_BYTES: usize pub const radroots_protocol::listing::LISTING_KIND: u32 +pub const radroots_protocol::listing::LISTING_TAG_MAX_COUNT: usize +pub const radroots_protocol::listing::LISTING_TAG_TOTAL_ELEMENT_MAX_COUNT: usize pub mod radroots_protocol::nip01 pub enum radroots_protocol::nip01::WireError pub radroots_protocol::nip01::WireError::InvalidInput @@ -570,6 +572,7 @@ pub enum radroots_protocol::plan::CapturedSigningPlan pub radroots_protocol::plan::CapturedSigningPlan::Chat(radroots_protocol::chat::ChatSigningPlan) pub radroots_protocol::plan::CapturedSigningPlan::Listing(radroots_protocol::listing::PublicSigningPlan) impl radroots_protocol::plan::CapturedSigningPlan +pub fn radroots_protocol::plan::CapturedSigningPlan::artifact(&self, radroots_protocol::plan::SigningTarget) -> core::result::Result<radroots_protocol::plan::SigningArtifact<'_>, radroots_protocol::nip01::WireError> pub const fn radroots_protocol::plan::CapturedSigningPlan::chat(&self) -> core::option::Option<&radroots_protocol::chat::ChatSigningPlan> pub const fn radroots_protocol::plan::CapturedSigningPlan::command_digest(&self) -> radroots_domain::identifier::CommandDigest pub const fn radroots_protocol::plan::CapturedSigningPlan::created_at(&self) -> radroots_domain::context::UnixSeconds @@ -585,10 +588,31 @@ impl core::convert::From<radroots_protocol::listing::PublicSigningPlan> for radr pub fn radroots_protocol::plan::CapturedSigningPlan::from(radroots_protocol::listing::PublicSigningPlan) -> Self impl core::fmt::Debug for radroots_protocol::plan::CapturedSigningPlan pub fn radroots_protocol::plan::CapturedSigningPlan::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub enum radroots_protocol::plan::SigningArtifact<'a> +pub radroots_protocol::plan::SigningArtifact::Public(&'a radroots_protocol::listing::ListingEvent) +pub radroots_protocol::plan::SigningArtifact::Seal(&'a radroots_protocol::chat::ChatSeal) +impl radroots_protocol::plan::SigningArtifact<'_> +pub fn radroots_protocol::plan::SigningArtifact<'_>::event_id(&self) -> [u8; 32] +pub fn radroots_protocol::plan::SigningArtifact<'_>::fields(&self) -> radroots_protocol::nip01::EventFields<'_> +pub fn radroots_protocol::plan::SigningArtifact<'_>::target(&self) -> radroots_protocol::plan::SigningTarget +impl core::fmt::Debug for radroots_protocol::plan::SigningArtifact<'_> +pub fn radroots_protocol::plan::SigningArtifact<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub enum radroots_protocol::plan::SigningReplay pub radroots_protocol::plan::SigningReplay::ExactReplayByRequestId pub radroots_protocol::plan::SigningReplay::LocalReplaySafe pub radroots_protocol::plan::SigningReplay::NonReplayable +pub enum radroots_protocol::plan::SigningTarget +pub radroots_protocol::plan::SigningTarget::BusinessSeal(radroots_identity::key::PublicKey) +pub radroots_protocol::plan::SigningTarget::PublicEvent +impl radroots_protocol::plan::SigningTarget +pub fn radroots_protocol::plan::SigningTarget::from_key(&[u8]) -> core::result::Result<Self, radroots_protocol::nip01::WireError> +pub fn radroots_protocol::plan::SigningTarget::key(self) -> alloc::vec::Vec<u8> +pub const fn radroots_protocol::plan::SigningTarget::recipient(self) -> core::option::Option<radroots_identity::key::PublicKey> +pub const fn radroots_protocol::plan::SigningTarget::role(self) -> radroots_protocol::intent::ArtifactRole +impl core::convert::From<radroots_identity::key::PublicKey> for radroots_protocol::plan::SigningTarget +pub fn radroots_protocol::plan::SigningTarget::from(radroots_identity::key::PublicKey) -> Self +impl core::fmt::Debug for radroots_protocol::plan::SigningTarget +pub fn radroots_protocol::plan::SigningTarget::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub mod radroots_protocol::radrootsd pub mod radroots_protocol::radrootsd::transport_publish pub mod radroots_protocol::radrootsd::transport_publish::v5 diff --git a/contracts/api_baselines/radroots_signing.txt b/contracts/api_baselines/radroots_signing.txt @@ -176,15 +176,16 @@ impl core::fmt::Debug for radroots_signing::issuance::SignedArtifact pub fn radroots_signing::issuance::SignedArtifact::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_signing::issuance::SigningIntent impl radroots_signing::issuance::SigningIntent -pub const fn radroots_signing::issuance::SigningIntent::author(&self) -> radroots_identity::key::PublicKey +pub fn radroots_signing::issuance::SigningIntent::author(&self) -> radroots_identity::key::PublicKey pub const fn radroots_signing::issuance::SigningIntent::binding(&self) -> radroots_protocol::intent::IntentBinding pub fn radroots_signing::issuance::SigningIntent::check_before_effect(&self, radroots_identity::key::PublicKey, u64) -> core::result::Result<(), radroots_signing::provider::ProviderError> pub fn radroots_signing::issuance::SigningIntent::from_chat_seal(radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, &radroots_protocol::chat::ChatSeal, radroots_signing::provider::ProviderCall) -> core::result::Result<Self, radroots_signing::provider::ProviderError> +pub fn radroots_signing::issuance::SigningIntent::from_plan(&radroots_protocol::plan::CapturedSigningPlan, radroots_protocol::plan::SigningTarget, radroots_signing::provider::ProviderCall) -> core::result::Result<Self, radroots_signing::provider::ProviderError> pub fn radroots_signing::issuance::SigningIntent::new(radroots_domain::identifier::OperationId, [u8; 32], radroots_event_codec::authoring::AuthoredEventPlan, radroots_protocol::intent::ArtifactRole, core::option::Option<radroots_identity::key::PublicKey>, radroots_signing::provider::ProviderCall) -> core::result::Result<Self, radroots_signing::provider::ProviderError> pub const fn radroots_signing::issuance::SigningIntent::recipient(&self) -> core::option::Option<radroots_identity::key::PublicKey> pub const fn radroots_signing::issuance::SigningIntent::role(&self) -> radroots_protocol::intent::ArtifactRole pub const fn radroots_signing::issuance::SigningIntent::signed_json_bytes(&self) -> usize -pub fn radroots_signing::issuance::SigningIntent::with_plan<T>(&self, impl core::ops::function::FnOnce(&radroots_event_codec::authoring::AuthoredEventPlan) -> T) -> T +pub fn radroots_signing::issuance::SigningIntent::with_event<T>(&self, impl core::ops::function::FnOnce(radroots_protocol::nip01::EventFields<'_>, radroots_event::id::EventId) -> T) -> T impl core::fmt::Debug for radroots_signing::issuance::SigningIntent pub fn radroots_signing::issuance::SigningIntent::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_signing::issuance::SigningOutcome diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -759,25 +759,26 @@ pub fn radroots_storage::memory::MemoryStorage::verify_backup(&self, radroots_st pub mod radroots_storage::command pub use radroots_storage::command::CapturedSigningPlan pub use radroots_storage::command::ChatSigningPlan +pub use radroots_storage::command::SigningTarget pub mod radroots_storage::command::protected pub mod radroots_storage::command::protected::issuance pub struct radroots_storage::command::protected::issuance::ClaimRecord(_) impl radroots_storage::command::protected::issuance::ClaimRecord pub fn radroots_storage::command::protected::issuance::ClaimRecord::capture(&radroots_storage::command::SigningAttempt) -> core::result::Result<Self, radroots_storage::command::OperationError> -pub fn radroots_storage::command::protected::issuance::ClaimRecord::decode(&[u8], radroots_storage::command::BoundSigningPlan, radroots_identity::key::PublicKey) -> core::result::Result<radroots_storage::command::SigningAttempt, radroots_storage::command::OperationError> +pub fn radroots_storage::command::protected::issuance::ClaimRecord::decode(&[u8], radroots_storage::command::BoundSigningPlan, impl core::convert::Into<radroots_protocol::plan::SigningTarget>) -> core::result::Result<radroots_storage::command::SigningAttempt, radroots_storage::command::OperationError> pub fn radroots_storage::command::protected::issuance::ClaimRecord::encode(&self) -> core::result::Result<zeroize::Zeroizing<alloc::vec::Vec<u8>>, radroots_storage::command::OperationError> pub struct radroots_storage::command::protected::issuance::EvidenceManifest(_) impl radroots_storage::command::protected::issuance::EvidenceManifest pub const fn radroots_storage::command::protected::issuance::EvidenceManifest::attempt_id(&self) -> radroots_domain::identifier::SigningAttemptId pub const fn radroots_storage::command::protected::issuance::EvidenceManifest::byte_count(&self) -> usize -pub fn radroots_storage::command::protected::issuance::EvidenceManifest::capture(&radroots_storage::command::SigningAttempt, &radroots_storage::command::SealEvidence, radroots_domain::identifier::TransactionId) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::command::protected::issuance::EvidenceManifest::capture(&radroots_storage::command::SigningAttempt, &radroots_storage::command::ArtifactEvidence, radroots_domain::identifier::TransactionId) -> core::result::Result<Self, radroots_storage::command::OperationError> pub fn radroots_storage::command::protected::issuance::EvidenceManifest::decode(&[u8], &radroots_storage::command::SigningAttempt) -> core::result::Result<Self, radroots_storage::command::OperationError> pub fn radroots_storage::command::protected::issuance::EvidenceManifest::encode(&self) -> core::result::Result<zeroize::Zeroizing<alloc::vec::Vec<u8>>, radroots_storage::command::OperationError> pub const fn radroots_storage::command::protected::issuance::EvidenceManifest::event_id(&self) -> radroots_domain::identifier::EnvelopeEventId pub const fn radroots_storage::command::protected::issuance::EvidenceManifest::evidence_digest(&self) -> &[u8; 32] pub const fn radroots_storage::command::protected::issuance::EvidenceManifest::part_count(&self) -> usize pub const fn radroots_storage::command::protected::issuance::EvidenceManifest::transaction_id(&self) -> radroots_domain::identifier::TransactionId -pub fn radroots_storage::command::protected::issuance::EvidenceManifest::verify(&self, &radroots_storage::command::SigningAttempt, &str) -> core::result::Result<radroots_storage::command::SealEvidence, radroots_storage::command::OperationError> +pub fn radroots_storage::command::protected::issuance::EvidenceManifest::verify(&self, &radroots_storage::command::SigningAttempt, &str) -> core::result::Result<radroots_storage::command::ArtifactEvidence, radroots_storage::command::OperationError> pub mod radroots_storage::command::protected::plan pub struct radroots_storage::command::protected::plan::PlanManifest(_) impl radroots_storage::command::protected::plan::PlanManifest @@ -883,6 +884,35 @@ pub fn radroots_storage::command::AdmissionRequest::new(radroots_storage::worksp pub fn radroots_storage::command::AdmissionRequest::validate_fresh(&self, radroots_domain::context::UnixSeconds) -> core::result::Result<(), radroots_storage::command::OperationError> impl core::fmt::Debug for radroots_storage::command::AdmissionRequest pub fn radroots_storage::command::AdmissionRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::command::ArtifactEvidence +impl radroots_storage::command::ArtifactEvidence +pub const fn radroots_storage::command::ArtifactEvidence::attempt_id(&self) -> radroots_domain::identifier::SigningAttemptId +pub const fn radroots_storage::command::ArtifactEvidence::command_digest(&self) -> radroots_domain::identifier::CommandDigest +pub const fn radroots_storage::command::ArtifactEvidence::digest(&self) -> &[u8; 32] +pub const fn radroots_storage::command::ArtifactEvidence::event_id(&self) -> radroots_domain::identifier::EnvelopeEventId +pub const fn radroots_storage::command::ArtifactEvidence::intent(&self) -> radroots_protocol::intent::IntentBinding +pub fn radroots_storage::command::ArtifactEvidence::matches_attempt(&self, &radroots_storage::command::SigningAttempt) -> bool +pub const fn radroots_storage::command::ArtifactEvidence::observed_at_unix_ms(&self) -> core::option::Option<core::num::nonzero::NonZeroU64> +pub const fn radroots_storage::command::ArtifactEvidence::operation_id(&self) -> radroots_domain::identifier::OperationId +pub const fn radroots_storage::command::ArtifactEvidence::plan_digest(&self) -> &[u8; 32] +pub fn radroots_storage::command::ArtifactEvidence::raw_json(&self) -> &str +pub fn radroots_storage::command::ArtifactEvidence::recipient(&self) -> core::result::Result<radroots_identity::key::PublicKey, radroots_storage::command::OperationError> +pub fn radroots_storage::command::ArtifactEvidence::retained_copy(&self) -> Self +pub const fn radroots_storage::command::ArtifactEvidence::target(&self) -> radroots_protocol::plan::SigningTarget +pub fn radroots_storage::command::ArtifactEvidence::verify(&radroots_storage::command::SigningAttempt, &str, core::option::Option<core::num::nonzero::NonZeroU64>) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::ArtifactEvidence::workspace_id(&self) -> radroots_domain::identifier::WorkspaceId +impl core::fmt::Debug for radroots_storage::command::ArtifactEvidence +pub fn radroots_storage::command::ArtifactEvidence::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::command::ArtifactSnapshot +impl radroots_storage::command::ArtifactSnapshot +pub const fn radroots_storage::command::ArtifactSnapshot::claim(self) -> core::option::Option<radroots_storage::command::ClaimSnapshot> +pub const fn radroots_storage::command::ArtifactSnapshot::expected_event(self) -> core::option::Option<radroots_domain::identifier::EnvelopeEventId> +pub fn radroots_storage::command::ArtifactSnapshot::from_store_report(impl core::convert::Into<radroots_protocol::plan::SigningTarget>, core::option::Option<radroots_domain::identifier::EnvelopeEventId>, core::option::Option<radroots_storage::command::ClaimSnapshot>, core::option::Option<radroots_storage::command::EvidenceReceipt>) -> Self +pub const fn radroots_storage::command::ArtifactSnapshot::obtained(self) -> core::option::Option<radroots_storage::command::EvidenceReceipt> +pub fn radroots_storage::command::ArtifactSnapshot::recipient(self) -> core::result::Result<radroots_identity::key::PublicKey, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::ArtifactSnapshot::target(self) -> radroots_protocol::plan::SigningTarget +impl core::fmt::Debug for radroots_storage::command::ArtifactSnapshot +pub fn radroots_storage::command::ArtifactSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::BoundSigningPlan impl radroots_storage::command::BoundSigningPlan pub const fn radroots_storage::command::BoundSigningPlan::bound_at(&self) -> radroots_domain::context::UnixSeconds @@ -894,14 +924,14 @@ pub const fn radroots_storage::command::BoundSigningPlan::prepared(&self) -> &ra pub const fn radroots_storage::command::BoundSigningPlan::transaction_id(&self) -> radroots_domain::identifier::TransactionId impl core::fmt::Debug for radroots_storage::command::BoundSigningPlan pub fn radroots_storage::command::BoundSigningPlan::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result -pub struct radroots_storage::command::CapturedSeal -impl radroots_storage::command::CapturedSeal -pub const fn radroots_storage::command::CapturedSeal::attempt(&self) -> &radroots_storage::command::SigningAttempt -pub const fn radroots_storage::command::CapturedSeal::evidence(&self) -> &radroots_storage::command::SealEvidence -pub fn radroots_storage::command::CapturedSeal::from_committed_store(radroots_storage::command::SigningAttempt, radroots_storage::command::SealEvidence, radroots_domain::identifier::TransactionId) -> core::result::Result<Self, radroots_storage::command::OperationError> -pub const fn radroots_storage::command::CapturedSeal::receipt(&self) -> radroots_storage::command::EvidenceReceipt -impl core::fmt::Debug for radroots_storage::command::CapturedSeal -pub fn radroots_storage::command::CapturedSeal::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::command::CapturedArtifact +impl radroots_storage::command::CapturedArtifact +pub const fn radroots_storage::command::CapturedArtifact::attempt(&self) -> &radroots_storage::command::SigningAttempt +pub const fn radroots_storage::command::CapturedArtifact::evidence(&self) -> &radroots_storage::command::ArtifactEvidence +pub fn radroots_storage::command::CapturedArtifact::from_committed_store(radroots_storage::command::SigningAttempt, radroots_storage::command::ArtifactEvidence, radroots_domain::identifier::TransactionId) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::CapturedArtifact::receipt(&self) -> radroots_storage::command::EvidenceReceipt +impl core::fmt::Debug for radroots_storage::command::CapturedArtifact +pub fn radroots_storage::command::CapturedArtifact::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::ChatInstallation impl radroots_storage::command::ChatInstallation pub const fn radroots_storage::command::ChatInstallation::basis(&self) -> radroots_storage::command::EvidenceReceipt @@ -921,11 +951,13 @@ pub struct radroots_storage::command::ClaimAttemptRequest impl radroots_storage::command::ClaimAttemptRequest pub const fn radroots_storage::command::ClaimAttemptRequest::binding(&self) -> &radroots_storage::workspace::WorkspaceBinding pub const fn radroots_storage::command::ClaimAttemptRequest::command_digest(&self) -> radroots_domain::identifier::CommandDigest +pub const fn radroots_storage::command::ClaimAttemptRequest::for_artifact(radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, [u8; 32], radroots_protocol::plan::SigningTarget) -> Self pub fn radroots_storage::command::ClaimAttemptRequest::identity(&self) -> radroots_storage::command::CommitAttempt pub const fn radroots_storage::command::ClaimAttemptRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, [u8; 32], radroots_identity::key::PublicKey) -> Self pub const fn radroots_storage::command::ClaimAttemptRequest::operation_id(&self) -> radroots_domain::identifier::OperationId pub const fn radroots_storage::command::ClaimAttemptRequest::plan_digest(&self) -> &[u8; 32] -pub const fn radroots_storage::command::ClaimAttemptRequest::recipient(&self) -> radroots_identity::key::PublicKey +pub fn radroots_storage::command::ClaimAttemptRequest::recipient(&self) -> core::result::Result<radroots_identity::key::PublicKey, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::ClaimAttemptRequest::target(&self) -> radroots_protocol::plan::SigningTarget impl core::fmt::Debug for radroots_storage::command::ClaimAttemptRequest pub fn radroots_storage::command::ClaimAttemptRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::ClaimSnapshot @@ -938,7 +970,8 @@ pub fn radroots_storage::command::ClaimSnapshot::from_store_report(&radroots_sto pub const fn radroots_storage::command::ClaimSnapshot::intent(self) -> radroots_protocol::intent::IntentBinding pub const fn radroots_storage::command::ClaimSnapshot::operation_id(self) -> radroots_domain::identifier::OperationId pub const fn radroots_storage::command::ClaimSnapshot::plan_digest(&self) -> &[u8; 32] -pub const fn radroots_storage::command::ClaimSnapshot::recipient(self) -> radroots_identity::key::PublicKey +pub fn radroots_storage::command::ClaimSnapshot::recipient(self) -> core::result::Result<radroots_identity::key::PublicKey, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::ClaimSnapshot::target(self) -> radroots_protocol::plan::SigningTarget pub const fn radroots_storage::command::ClaimSnapshot::transaction_id(self) -> radroots_domain::identifier::TransactionId pub const fn radroots_storage::command::ClaimSnapshot::workspace_id(self) -> radroots_domain::identifier::WorkspaceId impl core::fmt::Debug for radroots_storage::command::ClaimSnapshot @@ -1034,10 +1067,11 @@ pub const fn radroots_storage::command::EvidenceReceipt::attempt_id(&self) -> ra pub const fn radroots_storage::command::EvidenceReceipt::command_digest(&self) -> radroots_domain::identifier::CommandDigest pub const fn radroots_storage::command::EvidenceReceipt::digest(&self) -> &[u8; 32] pub const fn radroots_storage::command::EvidenceReceipt::event_id(&self) -> radroots_domain::identifier::EnvelopeEventId -pub const fn radroots_storage::command::EvidenceReceipt::from_committed_store(&radroots_storage::command::SealEvidence, radroots_domain::identifier::TransactionId) -> Self +pub const fn radroots_storage::command::EvidenceReceipt::from_committed_store(&radroots_storage::command::ArtifactEvidence, radroots_domain::identifier::TransactionId) -> Self pub const fn radroots_storage::command::EvidenceReceipt::observed_at_unix_ms(&self) -> core::option::Option<core::num::nonzero::NonZeroU64> pub const fn radroots_storage::command::EvidenceReceipt::operation_id(&self) -> radroots_domain::identifier::OperationId -pub const fn radroots_storage::command::EvidenceReceipt::recipient(&self) -> radroots_identity::key::PublicKey +pub fn radroots_storage::command::EvidenceReceipt::recipient(&self) -> core::result::Result<radroots_identity::key::PublicKey, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::EvidenceReceipt::target(&self) -> radroots_protocol::plan::SigningTarget pub const fn radroots_storage::command::EvidenceReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId pub const fn radroots_storage::command::EvidenceReceipt::workspace_id(&self) -> radroots_domain::identifier::WorkspaceId pub struct radroots_storage::command::InstallationRequest @@ -1052,11 +1086,12 @@ impl core::fmt::Debug for radroots_storage::command::InstallationRequest pub fn radroots_storage::command::InstallationRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::OperationSnapshot impl radroots_storage::command::OperationSnapshot +pub fn radroots_storage::command::OperationSnapshot::artifacts(&self) -> &[radroots_storage::command::ArtifactSnapshot] pub fn radroots_storage::command::OperationSnapshot::bound_plan(&self) -> core::option::Option<&radroots_storage::command::BoundSigningPlan> pub fn radroots_storage::command::OperationSnapshot::checkpoint_digest(&self) -> radroots_domain::identifier::CheckpointDigest pub fn radroots_storage::command::OperationSnapshot::delivery_attempts(&self) -> &[radroots_storage::command::DeliveryAttemptSummary] pub fn radroots_storage::command::OperationSnapshot::delivery_observations(&self) -> &[radroots_storage::command::DeliveryObservation] -pub fn radroots_storage::command::OperationSnapshot::from_store_report(radroots_storage::command::RetainedOperation, alloc::vec::Vec<radroots_storage::command::RecipientSnapshot>, radroots_domain::context::UnixSeconds) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::command::OperationSnapshot::from_store_report(radroots_storage::command::RetainedOperation, alloc::vec::Vec<radroots_storage::command::ArtifactSnapshot>, radroots_domain::context::UnixSeconds) -> core::result::Result<Self, radroots_storage::command::OperationError> pub const fn radroots_storage::command::OperationSnapshot::installation(&self) -> core::option::Option<radroots_storage::command::ChatInstallation> pub fn radroots_storage::command::OperationSnapshot::installed_message(&self) -> core::option::Option<&radroots_domain::message::ChatMessage> pub fn radroots_storage::command::OperationSnapshot::message_id(&self) -> core::option::Option<radroots_domain::identifier::MessageId> @@ -1064,7 +1099,6 @@ pub const fn radroots_storage::command::OperationSnapshot::observed_at(&self) -> pub fn radroots_storage::command::OperationSnapshot::prepared(&self) -> &radroots_storage::command::PreparedOperation 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::publications(&self) -> &[radroots_storage::command::PublicationWork] -pub fn radroots_storage::command::OperationSnapshot::recipients(&self) -> &[radroots_storage::command::RecipientSnapshot] 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> impl core::fmt::Debug for radroots_storage::command::OperationSnapshot @@ -1086,36 +1120,10 @@ pub fn radroots_storage::command::PublicationWork::from_committed_store(&radroot pub const fn radroots_storage::command::PublicationWork::installation_transaction_id(&self) -> radroots_domain::identifier::TransactionId pub const fn radroots_storage::command::PublicationWork::plan_digest(&self) -> &[u8; 32] 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::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::RecipientSnapshot -impl radroots_storage::command::RecipientSnapshot -pub const fn radroots_storage::command::RecipientSnapshot::claim(self) -> core::option::Option<radroots_storage::command::ClaimSnapshot> -pub const fn radroots_storage::command::RecipientSnapshot::expected_event(self) -> core::option::Option<radroots_domain::identifier::EnvelopeEventId> -pub const fn radroots_storage::command::RecipientSnapshot::from_store_report(radroots_identity::key::PublicKey, core::option::Option<radroots_domain::identifier::EnvelopeEventId>, core::option::Option<radroots_storage::command::ClaimSnapshot>, core::option::Option<radroots_storage::command::EvidenceReceipt>) -> Self -pub const fn radroots_storage::command::RecipientSnapshot::obtained(self) -> core::option::Option<radroots_storage::command::EvidenceReceipt> -pub const fn radroots_storage::command::RecipientSnapshot::recipient(self) -> radroots_identity::key::PublicKey -impl core::fmt::Debug for radroots_storage::command::RecipientSnapshot -pub fn radroots_storage::command::RecipientSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result -pub struct radroots_storage::command::SealEvidence -impl radroots_storage::command::SealEvidence -pub const fn radroots_storage::command::SealEvidence::attempt_id(&self) -> radroots_domain::identifier::SigningAttemptId -pub const fn radroots_storage::command::SealEvidence::command_digest(&self) -> radroots_domain::identifier::CommandDigest -pub const fn radroots_storage::command::SealEvidence::digest(&self) -> &[u8; 32] -pub const fn radroots_storage::command::SealEvidence::event_id(&self) -> radroots_domain::identifier::EnvelopeEventId -pub const fn radroots_storage::command::SealEvidence::intent(&self) -> radroots_protocol::intent::IntentBinding -pub fn radroots_storage::command::SealEvidence::matches_attempt(&self, &radroots_storage::command::SigningAttempt) -> bool -pub const fn radroots_storage::command::SealEvidence::observed_at_unix_ms(&self) -> core::option::Option<core::num::nonzero::NonZeroU64> -pub const fn radroots_storage::command::SealEvidence::operation_id(&self) -> radroots_domain::identifier::OperationId -pub const fn radroots_storage::command::SealEvidence::plan_digest(&self) -> &[u8; 32] -pub fn radroots_storage::command::SealEvidence::raw_json(&self) -> &str -pub const fn radroots_storage::command::SealEvidence::recipient(&self) -> radroots_identity::key::PublicKey -pub fn radroots_storage::command::SealEvidence::retained_copy(&self) -> Self -pub fn radroots_storage::command::SealEvidence::verify(&radroots_storage::command::SigningAttempt, &str, core::option::Option<core::num::nonzero::NonZeroU64>) -> core::result::Result<Self, radroots_storage::command::OperationError> -pub const fn radroots_storage::command::SealEvidence::workspace_id(&self) -> radroots_domain::identifier::WorkspaceId -impl core::fmt::Debug for radroots_storage::command::SealEvidence -pub fn radroots_storage::command::SealEvidence::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::SignedDmRelaySource impl radroots_storage::command::SignedDmRelaySource pub const fn radroots_storage::command::SignedDmRelaySource::created_at(&self) -> radroots_domain::context::UnixSeconds @@ -1129,31 +1137,33 @@ impl core::fmt::Debug for radroots_storage::command::SignedDmRelaySource pub fn radroots_storage::command::SignedDmRelaySource::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage::command::SigningAttempt impl radroots_storage::command::SigningAttempt +pub fn radroots_storage::command::SigningAttempt::artifact(&self) -> core::result::Result<radroots_protocol::plan::SigningArtifact<'_>, radroots_storage::command::OperationError> pub const fn radroots_storage::command::SigningAttempt::attempt_id(&self) -> radroots_domain::identifier::SigningAttemptId pub const fn radroots_storage::command::SigningAttempt::binding(&self) -> radroots_protocol::intent::IntentBinding pub const fn radroots_storage::command::SigningAttempt::bound_plan(&self) -> &radroots_storage::command::BoundSigningPlan pub const fn radroots_storage::command::SigningAttempt::claimed_at(&self) -> radroots_domain::context::UnixSeconds pub const fn radroots_storage::command::SigningAttempt::deadline_unix_ms(&self) -> core::num::nonzero::NonZeroU64 -pub fn radroots_storage::command::SigningAttempt::from_committed_store(radroots_storage::command::BoundSigningPlan, radroots_identity::key::PublicKey, radroots_domain::identifier::SigningAttemptId, radroots_domain::identifier::TransactionId, radroots_domain::context::UnixSeconds) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::command::SigningAttempt::from_committed_store(radroots_storage::command::BoundSigningPlan, impl core::convert::Into<radroots_protocol::plan::SigningTarget>, radroots_domain::identifier::SigningAttemptId, radroots_domain::identifier::TransactionId, radroots_domain::context::UnixSeconds) -> core::result::Result<Self, radroots_storage::command::OperationError> pub fn radroots_storage::command::SigningAttempt::identity(&self) -> radroots_storage::command::CommitAttempt pub fn radroots_storage::command::SigningAttempt::into_bound_plan(self) -> radroots_storage::command::BoundSigningPlan pub fn radroots_storage::command::SigningAttempt::seal(&self) -> core::result::Result<&radroots_protocol::chat::ChatSeal, radroots_storage::command::OperationError> +pub const fn radroots_storage::command::SigningAttempt::target(&self) -> radroots_protocol::plan::SigningTarget pub const fn radroots_storage::command::SigningAttempt::transaction_id(&self) -> radroots_domain::identifier::TransactionId impl core::fmt::Debug for radroots_storage::command::SigningAttempt pub fn radroots_storage::command::SigningAttempt::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub trait radroots_storage::command::OperationJournal: radroots_storage::workspace::WorkspaceStore pub fn radroots_storage::command::OperationJournal::admit_command_and_hold(&self, radroots_storage::command::AdmissionRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::AdmissionOutcome, radroots_storage::command::OperationError>> 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::SealEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::EvidenceCaptureOutcome, 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::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::CapturedSeal>, 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>> pub fn radroots_storage::command::OperationJournal::operation_snapshot(&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::OperationSnapshot>, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::prepare_delivery_attempt<'a>(&'a self, radroots_storage::command::DeliveryAttemptRequest, radroots_storage::workspace::AttachmentProof, core::option::Option<&'a radroots_storage::command::EnvelopeCandidate>) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::DeliveryAttemptOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage::command::OperationJournal::reconcile_unknown<'a>(&'a self, radroots_storage::workspace::AttachmentInput, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::SealEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage::command::OperationJournal::reconcile_unknown<'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::record_delivery_observation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::AttachmentProof, radroots_storage::command::DeliveryObservation) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::DeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::signing_attempt(&self, radroots_storage::command::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::SigningAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage::command::OperationJournal::signing_plan(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::BoundSigningPlan>, 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 @@ -6,12 +6,12 @@ impl radroots_storage_indexeddb::workspace::BrowserWorkspace pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::admit_command_and_hold(&self, radroots_storage::command::AdmissionRequest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::command::AdmissionOutcome, radroots_storage::command::OperationError> pub async 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) -> core::result::Result<core::option::Option<radroots_storage::command::PreparedOperation>, radroots_storage::command::OperationError> impl radroots_storage_indexeddb::workspace::BrowserWorkspace -pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::bind_signing_intents(&self, radroots_storage::workspace::WorkspaceBinding, radroots_protocol::chat::plan::ChatSigningPlan, radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::command::PlanBindingOutcome, radroots_storage::command::OperationError> +pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::bind_signing_intents(&self, radroots_storage::workspace::WorkspaceBinding, radroots_protocol::plan::CapturedSigningPlan, radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::command::PlanBindingOutcome, radroots_storage::command::OperationError> pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::signing_plan(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::command::BoundSigningPlan>, radroots_storage::command::OperationError> impl radroots_storage_indexeddb::workspace::BrowserWorkspace -pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::capture_evidence(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof, &radroots_storage::command::issuance::SealEvidence) -> core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError> +pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::capture_evidence(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof, &radroots_storage::command::issuance::ArtifactEvidence) -> core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError> pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::claim_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::command::issuance::ClaimAttemptOutcome, radroots_storage::command::OperationError> -pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::obtained_evidence(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::command::issuance::CapturedSeal>, radroots_storage::command::OperationError> +pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::obtained_evidence(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::command::issuance::CapturedArtifact>, radroots_storage::command::OperationError> pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::signing_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::command::issuance::SigningAttempt>, radroots_storage::command::OperationError> impl radroots_storage_indexeddb::workspace::BrowserWorkspace pub async fn radroots_storage_indexeddb::workspace::BrowserWorkspace::close(&self) -> core::result::Result<(), radroots_storage::workspace::WorkspaceError> @@ -32,17 +32,17 @@ impl core::fmt::Debug for radroots_storage_indexeddb::workspace::BrowserWorkspac pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl radroots_storage::command::OperationJournal for radroots_storage_indexeddb::workspace::BrowserWorkspace pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::admit_command_and_hold(&self, radroots_storage::command::AdmissionRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::AdmissionOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::bind_signing_intents(&self, radroots_storage::workspace::WorkspaceBinding, radroots_protocol::chat::plan::ChatSigningPlan, 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::SealEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> +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::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::CapturedSeal>, 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>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::operation_snapshot(&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::snapshot::OperationSnapshot>, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::prepare_delivery_attempt<'a>(&'a self, radroots_storage::command::delivery::DeliveryAttemptRequest, radroots_storage::workspace::AttachmentProof, core::option::Option<&'a radroots_storage::command::delivery::EnvelopeCandidate>) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::delivery::DeliveryAttemptOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::reconcile_unknown<'a>(&'a self, radroots_storage::workspace::AttachmentInput, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::issuance::SealEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::reconcile_unknown<'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::record_delivery_observation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::AttachmentProof, radroots_storage::command::observation::DeliveryObservation) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::observation::DeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::signing_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::issuance::SigningAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage_indexeddb::workspace::BrowserWorkspace::signing_plan(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::BoundSigningPlan>, radroots_storage::command::OperationError>> diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -379,16 +379,16 @@ pub fn radroots_storage_sqlite::workspace::NativeWorkspace::fmt(&self, &mut core impl radroots_storage::command::OperationJournal for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::admit_command_and_hold(&self, radroots_storage::command::AdmissionRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::AdmissionOutcome, radroots_storage::command::OperationError>> 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::SealEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, 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::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::CapturedSeal>, 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>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::operation_snapshot(&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::snapshot::OperationSnapshot>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::prepare_delivery_attempt<'a>(&'a self, radroots_storage::command::delivery::DeliveryAttemptRequest, radroots_storage::workspace::AttachmentProof, core::option::Option<&'a radroots_storage::command::delivery::EnvelopeCandidate>) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::delivery::DeliveryAttemptOutcome, radroots_storage::command::OperationError>> -pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_unknown<'a>(&'a self, radroots_storage::workspace::AttachmentInput, &'a radroots_storage::workspace::AttachmentProof, &'a radroots_storage::command::issuance::SealEvidence) -> radroots_transport::source::BoxFuture<'a, core::result::Result<radroots_storage::command::issuance::EvidenceCaptureOutcome, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::reconcile_unknown<'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::record_delivery_observation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::AttachmentProof, radroots_storage::command::observation::DeliveryObservation) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::command::observation::DeliveryObservationOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::signing_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::issuance::SigningAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::signing_plan(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::BoundSigningPlan>, radroots_storage::command::OperationError>> diff --git a/crates/execution/Cargo.toml b/crates/execution/Cargo.toml @@ -17,7 +17,7 @@ default = [] session = ["dep:futures"] signer_session = ["session", "dep:radroots_signing"] client_session = ["signer_session"] -workspace_session = ["client_session", "receipts", "radroots_protocol/commands", "radroots_signing/chat", "dep:radroots_transport"] +workspace_session = ["client_session", "receipts", "radroots_protocol/commands", "radroots_signing/artifacts", "dep:radroots_transport"] receipts = ["dep:radroots_storage", "radroots_storage/command_journal"] [dependencies] diff --git a/crates/execution/src/receipt.rs b/crates/execution/src/receipt.rs @@ -451,8 +451,8 @@ impl OperationReceipt<ChatMessage> { pub fn from_snapshot(snapshot: &radroots_storage::command::OperationSnapshot) -> Self { use alloc::{vec, vec::Vec}; let prepared = snapshot.prepared(); - let mut artifacts = Vec::with_capacity(snapshot.recipients().len()); - for recipient in snapshot.recipients() { + let mut artifacts = Vec::with_capacity(snapshot.artifacts().len()); + for recipient in snapshot.artifacts() { let claim = recipient.claim(); let obtained = recipient.obtained(); let issuance = if obtained.is_some() { @@ -465,8 +465,15 @@ impl OperationReceipt<ChatMessage> { Issuance::None }; artifacts.push(ArtifactObservation { - role: ArtifactRole::BusinessSeal, - recipient: Some(recipient.recipient()), + role: match recipient.target() { + radroots_protocol::plan::SigningTarget::PublicEvent => { + ArtifactRole::PublicEvent + } + radroots_protocol::plan::SigningTarget::BusinessSeal(_) => { + ArtifactRole::BusinessSeal + } + }, + recipient: recipient.target().recipient(), expected_event: recipient.expected_event(), issuance, attempt: claim.map(|value| value.attempt_id()), @@ -527,7 +534,7 @@ impl OperationReceipt<ChatMessage> { use radroots_storage::command::DeliveryObservationKind as Kind; DeliveryObservation { event: value.event_id(), - recipient: Some(value.work().evidence().recipient()), + recipient: value.work().evidence().target().recipient(), target: value.target_receipt().target().uri().as_str().into(), request: value.request_id().as_str().into(), target_fingerprint: value diff --git a/crates/execution/src/session/inquiry.rs b/crates/execution/src/session/inquiry.rs @@ -16,10 +16,10 @@ use radroots_signing::{ }; use radroots_storage::{ command::{ - BoundSigningPlan, ClaimAttemptOutcome, ClaimAttemptRequest, DeliveryAttemptOutcome, - DeliveryAttemptRequest, DeliveryIntent, DeliveryObservation, EnvelopeCandidate, - EvidenceCaptureOutcome, InstallationRequest, OperationError, OperationJournal, - PlanBindingOutcome, PreparedOperation, PublicationWork, SealEvidence, + ArtifactEvidence, BoundSigningPlan, ClaimAttemptOutcome, ClaimAttemptRequest, + DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryIntent, DeliveryObservation, + EnvelopeCandidate, EvidenceCaptureOutcome, InstallationRequest, OperationError, + OperationJournal, PlanBindingOutcome, PreparedOperation, PublicationWork, }, workspace::{AttachmentProof, WorkspaceBinding}, }; @@ -67,7 +67,7 @@ struct PendingCapture { journal: Shared<dyn OperationJournal>, binding: WorkspaceBinding, proof: AttachmentProof, - evidence: SealEvidence, + evidence: ArtifactEvidence, // Keeps both the resource permit and conservative live-byte reservation. _lease: Shared<dyn HostBound>, } @@ -231,7 +231,7 @@ impl InquiryRuntime { .await? .ok_or(OperationError::RecoveryRequired)?; if snapshot - .recipients() + .artifacts() .iter() .any(|recipient| recipient.obtained().is_some()) { @@ -377,10 +377,9 @@ impl InquiryRuntime { ClaimAttemptOutcome::Retained(_) | ClaimAttemptOutcome::Unknown(_) => continue, }, }; - let intent = SigningIntent::from_chat_seal( - prepared.identity().operation_id(), - prepared.identity().command_digest(), - attempt.seal()?, + let intent = SigningIntent::from_plan( + attempt.bound_plan().plan(), + attempt.target(), ProviderCall::new( attempt.seal()?.fields().author, attempt.deadline_unix_ms(), @@ -395,7 +394,7 @@ impl InquiryRuntime { let (_, kind) = outcome.into_parts(); if let OutcomeKind::Obtained(artifact) = kind { let evidence = artifact.with_json(|raw| { - SealEvidence::verify(&attempt, raw, artifact.observed_at_unix_ms()) + ArtifactEvidence::verify(&attempt, raw, artifact.observed_at_unix_ms()) })?; let entry = Shared::new(PendingCapture { journal: journal.clone(), @@ -453,7 +452,7 @@ impl InquiryRuntime { if original.is_some() && matches!(mode, RunMode::Command) { continue; } - let recipient = work.evidence().recipient(); + let recipient = work.recipient(); let route = bound .chat_plan()? .routes() diff --git a/crates/execution/tests/support/workspace_commands.rs b/crates/execution/tests/support/workspace_commands.rs @@ -149,12 +149,7 @@ impl OperationJournal for Journal { assert!(expected_digest.is_none_or(|digest| digest == request.command().digest())); let snapshot = OperationSnapshot::from_store_report( RetainedOperation::Prepared(prepared(request)), - vec![RecipientSnapshot::from_store_report( - key(), - None, - None, - None, - )], + vec![ArtifactSnapshot::from_store_report(key(), None, None, None)], UnixSeconds::new(101).unwrap(), ) .unwrap(); @@ -179,7 +174,7 @@ impl OperationJournal for Journal { &'a self, _input: radroots_storage::workspace::AttachmentInput, _proof: &'a AttachmentProof, - _evidence: &'a SealEvidence, + _evidence: &'a ArtifactEvidence, ) -> BoxFuture<'a, Result<EvidenceCaptureOutcome, OperationError>> { panic!("unexpected journal effect") } @@ -187,7 +182,7 @@ impl OperationJournal for Journal { &self, _request: ClaimAttemptRequest, _proof: AttachmentProof, - ) -> BoxFuture<'_, Result<Option<CapturedSeal>, OperationError>> { + ) -> BoxFuture<'_, Result<Option<CapturedArtifact>, OperationError>> { panic!("unexpected journal effect") } fn bind_signing_intents( diff --git a/crates/nostr/Cargo.toml b/crates/nostr/Cargo.toml @@ -49,8 +49,9 @@ events = [ "radroots_event/serde", "radroots_event_codec/json", ] -nip17 = ["events", "nostr/nip44", "nostr/nip59", "dep:base64", "dep:radroots_protocol"] +nip17 = ["events", "nostr/nip44", "nostr/nip59", "dep:base64", "radroots_protocol/chat"] signing = [ + "dep:radroots_protocol", "events", "dep:radroots_signing", "nostr/nip49", @@ -64,7 +65,7 @@ radroots_event = { workspace = true, default-features = false } radroots_event_codec = { workspace = true, default-features = false } radroots_identity = { workspace = true, default-features = false } radroots_signing = { workspace = true, optional = true, default-features = false } -radroots_protocol = { workspace = true, optional = true, default-features = false, features = ["chat"] } +radroots_protocol = { workspace = true, optional = true, default-features = false, features = ["nip01"] } nostr = { workspace = true, default-features = false, features = ["alloc"] } zeroize = { workspace = true, default-features = false, features = ["alloc"] } serde = { workspace = true, default-features = false, features = [ diff --git a/crates/nostr/src/plan_signing.rs b/crates/nostr/src/plan_signing.rs @@ -53,6 +53,43 @@ pub(crate) fn unsigned_event_from_plan( } #[cfg(feature = "signing")] +pub(crate) fn unsigned_event_from_fields( + fields: radroots_protocol::nip01::EventFields<'_>, + expected_id: radroots_event::id::EventId, +) -> Result<nostr::UnsignedEvent, Error> { + let kind = u16::try_from(fields.kind).map_err(|_| Error::KindOutOfRange { + kind: fields.kind, + max: u16::MAX, + })?; + let tags = fields + .tags + .iter() + .cloned() + .map(RadrootsNostrTag::parse) + .collect::<Result<alloc::vec::Vec<_>, _>>() + .map_err(|_| Error::TagConversion)?; + let pubkey = RadrootsNostrPublicKey::from_slice(fields.author.as_bytes()) + .map_err(|_| Error::EventConversion { field: "author" })?; + let created_at = RadrootsNostrTimestamp::from_secs(fields.created_at); + let kind = RadrootsNostrKind::Custom(kind); + let tags = nostr::Tags::from_list(tags); + let id = RadrootsNostrEventId::new(&pubkey, &created_at, &kind, &tags, fields.content); + if id.as_bytes() != expected_id.as_bytes() { + return Err(Error::ExternalSigningPlanMismatch { + field: "expected_event_id", + }); + } + Ok(nostr::UnsignedEvent { + id: Some(id), + pubkey, + created_at, + kind, + tags, + content: fields.content.into(), + }) +} + +#[cfg(feature = "signing")] fn unsigned_event_from_request(request: &SignRequest) -> Result<nostr::UnsignedEvent, Error> { let kind = u16::try_from(request.kind()).map_err(|_| Error::KindOutOfRange { kind: request.kind(), diff --git a/crates/nostr/src/signing/issuance.rs b/crates/nostr/src/signing/issuance.rs @@ -16,7 +16,8 @@ impl LocalSigner { return SigningOutcome::not_dispatched(binding, ProviderError::IdentityChanged); } // Conversion/representation errors occur before cryptography. - let unsigned = match intent.with_plan(crate::plan_signing::unsigned_event_from_plan) { + let unsigned = match intent.with_event(crate::plan_signing::unsigned_event_from_fields) + { Ok(unsigned) => unsigned, Err(_) => { return SigningOutcome::not_dispatched(binding, ProviderError::InvalidInput); @@ -191,7 +192,18 @@ mod tests { SigningIntent::new( intent.binding().operation_id(), [9; 32], - intent.with_plan(Clone::clone), + intent.with_event(|fields, _| AuthoredEventPlan::from_generic( + GenericEventDraft::new( + "radroots.social.geochat.v1", + fields.kind, + fields.created_at, + fields.tags.to_vec(), + fields.content, + fields.author.to_hex() + ) + .unwrap() + ) + .unwrap()), ArtifactRole::PublicEvent, None, ProviderCall::new( diff --git a/crates/protocol/Cargo.toml b/crates/protocol/Cargo.toml @@ -37,8 +37,8 @@ std = ["serde?/std"] commands = ["serde", "dep:radroots_domain", "dep:serde_json", "dep:sha2", "dep:zeroize"] intent = ["dep:radroots_domain", "dep:sha2"] nip01 = ["dep:radroots_identity", "dep:sha2", "dep:zeroize"] -chat = ["commands", "nip01"] -listing = ["commands", "nip01"] +chat = ["commands", "nip01", "intent"] +listing = ["commands", "nip01", "intent"] [dependencies] radroots_identity = { workspace = true, default-features = false, optional = true } diff --git a/crates/protocol/src/listing.rs b/crates/protocol/src/listing.rs @@ -27,6 +27,10 @@ pub use plan::PublicSigningPlan; pub const LISTING_KIND: u32 = 30402; /// Complete public event cap, including NIP-01 key, ID and signature framing. pub const LISTING_EVENT_MAX_BYTES: usize = 65_536; +/// The closed public profile emits at most eight ordered two-field tags. +pub const LISTING_TAG_MAX_COUNT: usize = 8; +/// Both key and value count toward the closed public profile's field budget. +pub const LISTING_TAG_TOTAL_ELEMENT_MAX_COUNT: usize = 16; /// Explicit immutable public-offer input; no IDs, time or authority are inferred. #[derive(Clone, Serialize)] @@ -125,6 +129,7 @@ fn serialize_profile<S: serde::Serializer>( /// Retained exact public event fields. This value contains no signature and /// supplies no evidence of T0/T1, signer invocation, installation or delivery. +#[derive(Clone)] pub struct ListingEvent { author: PublicKey, created_at: UnixSeconds, diff --git a/crates/protocol/src/plan.rs b/crates/protocol/src/plan.rs @@ -1,7 +1,114 @@ //! Common immutable signing-plan data, with explicit artifact families. -use crate::{command::CapturedCommand, nip01::WireError}; +use crate::{ + command::CapturedCommand, + intent::ArtifactRole, + nip01::{EventFields, WireError}, +}; +use alloc::vec::Vec; use core::fmt; -use radroots_domain::{CommandDigest, OperationId, UnixSeconds}; +use radroots_domain::{CommandDigest, OperationId, PublicKey, UnixSeconds}; + +/// Exact T1 artifact selection. Public events have no invented private peer. +/// Selection is data only and establishes neither authority nor an invocation. +#[derive(Clone, Copy, Eq, PartialEq, Hash)] +pub enum SigningTarget { + /// The single exact public event in a public plan. + PublicEvent, + /// One exact recipient's business seal in a private plan. + BusinessSeal(PublicKey), +} +impl SigningTarget { + /// Role bound by the selected plan artifact. + pub const fn role(self) -> ArtifactRole { + match self { + Self::PublicEvent => ArtifactRole::PublicEvent, + Self::BusinessSeal(_) => ArtifactRole::BusinessSeal, + } + } + /// No public event is represented by a participant key. + pub const fn recipient(self) -> Option<PublicKey> { + match self { + Self::PublicEvent => None, + Self::BusinessSeal(peer) => Some(peer), + } + } + /// Bounded unambiguous storage selector. Its public tag is not a recipient. + pub fn key(self) -> Vec<u8> { + match self { + Self::PublicEvent => alloc::vec![0], + Self::BusinessSeal(peer) => peer.as_bytes().to_vec(), + } + } + /// Decodes only the exact supported tagged selector profiles. + pub fn from_key(key: &[u8]) -> Result<Self, WireError> { + match key { + [0] => Ok(Self::PublicEvent), + rest if rest.len() == 32 => { + PublicKey::from_bytes(rest.try_into().map_err(|_| WireError::InvalidInput)?) + .map(Self::BusinessSeal) + .map_err(|_| WireError::InvalidInput) + } + _ => Err(WireError::InvalidInput), + } + } +} +impl From<PublicKey> for SigningTarget { + fn from(recipient: PublicKey) -> Self { + Self::BusinessSeal(recipient) + } +} +impl fmt::Debug for SigningTarget { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::PublicEvent => "SigningTarget::PublicEvent", + Self::BusinessSeal(_) => "SigningTarget::BusinessSeal(<redacted>)", + }) + } +} + +/// Borrowed exact known artifact. This authenticates no signer or store fact. +pub enum SigningArtifact<'a> { + /// Exact assigned-kind public listing. + #[cfg(feature = "listing")] + Public(&'a crate::listing::ListingEvent), + /// Exact private business seal, with its actual recipient. + #[cfg(feature = "chat")] + Seal(&'a crate::chat::ChatSeal), +} +impl SigningArtifact<'_> { + /// Borrows original NIP-01 fields without rebuilding content or tags. + pub fn fields(&self) -> EventFields<'_> { + match self { + #[cfg(feature = "listing")] + Self::Public(event) => event.fields(), + #[cfg(feature = "chat")] + Self::Seal(seal) => seal.fields(), + } + } + /// Original exact event ID. + pub fn event_id(&self) -> [u8; 32] { + match self { + #[cfg(feature = "listing")] + Self::Public(event) => *event.event_id(), + #[cfg(feature = "chat")] + Self::Seal(seal) => seal.event_id(), + } + } + /// Exact role/recipient pair without a public-peer fallback. + pub fn target(&self) -> SigningTarget { + match self { + #[cfg(feature = "listing")] + Self::Public(_) => SigningTarget::PublicEvent, + #[cfg(feature = "chat")] + Self::Seal(seal) => SigningTarget::BusinessSeal(seal.recipient()), + } + } +} +impl fmt::Debug for SigningArtifact<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("SigningArtifact(<redacted>)") + } +} /// Captured provider declaration. Execution must independently verify current /// support before any reissue; this data authenticates no provider guarantee. @@ -43,6 +150,23 @@ pub enum CapturedSigningPlan { Listing(crate::listing::PublicSigningPlan), } impl CapturedSigningPlan { + /// Resolves only an actual retained artifact in this exact plan family. + pub fn artifact(&self, target: SigningTarget) -> Result<SigningArtifact<'_>, WireError> { + match (self, target) { + #[cfg(feature = "listing")] + (Self::Listing(plan), SigningTarget::PublicEvent) => { + Ok(SigningArtifact::Public(plan.event())) + } + #[cfg(feature = "chat")] + (Self::Chat(plan), SigningTarget::BusinessSeal(peer)) => plan + .seals() + .iter() + .find(|seal| seal.recipient() == peer) + .map(SigningArtifact::Seal) + .ok_or(WireError::InvalidInput), + _ => Err(WireError::InvalidInput), + } + } /// Reconstructs only the family of the independently retained command. pub fn parse(command: &CapturedCommand, wire: &[u8]) -> Result<Self, WireError> { match command { diff --git a/crates/protocol/tests/public_command.rs b/crates/protocol/tests/public_command.rs @@ -300,3 +300,23 @@ fn exact_public_plan_reconstructs_original_event_and_refuses_changed_framing_or_ .is_err() ); } + +#[test] +fn artifact_selection_has_no_public_participant_and_preserves_private_keys() { + use radroots_protocol::plan::SigningTarget; + let public = SigningTarget::PublicEvent; + assert_eq!(public.recipient(), None); + assert_eq!(public.key(), [0]); + assert_eq!(SigningTarget::from_key(&[0]).unwrap(), public); + let key = radroots_domain::PublicKey::from_hex( + "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", + ) + .unwrap(); + let private = SigningTarget::BusinessSeal(key); + assert_eq!(private.recipient(), Some(key)); + assert_eq!(private.key(), key.as_bytes()); + assert_eq!(SigningTarget::from_key(key.as_bytes()).unwrap(), private); + for invalid in [&[][..], &[1][..], &[0, 0][..], &[1; 31][..], &[1; 33][..]] { + assert!(SigningTarget::from_key(invalid).is_err()); + } +} diff --git a/crates/radroots/src/native_inquiry.rs b/crates/radroots/src/native_inquiry.rs @@ -145,7 +145,7 @@ impl InquiryIo for NativeInquiry { raw_seal: &str, ) -> Result<EnvelopeCandidate, OperationError> { let now = NonZeroU64::new(self.now()?.get()).ok_or(OperationError::RecoveryRequired)?; - let recipient = work.evidence().recipient(); + let recipient = work.recipient(); let wrapped = wrap_retained_seal(raw_seal, recipient, now, &OsNonceSource) .map_err(|_| OperationError::InvalidEvidence)?; wrapped.with_wrapping_key(|key| { diff --git a/crates/radroots/tests/support/receipt_delivery.rs b/crates/radroots/tests/support/receipt_delivery.rs @@ -10,10 +10,10 @@ use radroots_signing::{ request::CancellationSignal, }; use radroots_storage::command::{ - DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryIntent, - DeliveryObservation, DeliveryObservationKind, DeliveryObservationOutcome, EnvelopeCandidate, - EvidenceCaptureOutcome, InstallationOutcome, InstallationRequest, PublicationWork, - SealEvidence, + ArtifactEvidence, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, + DeliveryIntent, DeliveryObservation, DeliveryObservationKind, DeliveryObservationOutcome, + EnvelopeCandidate, EvidenceCaptureOutcome, InstallationOutcome, InstallationRequest, + PublicationWork, }; use radroots_transport::{ EventSink, TargetSet, @@ -128,7 +128,7 @@ impl Ready { panic!("synthetic participant seal must be obtained") }; let seal = artifact.with_json(|raw| { - SealEvidence::verify(&claim, raw, artifact.observed_at_unix_ms()).unwrap() + ArtifactEvidence::verify(&claim, raw, artifact.observed_at_unix_ms()).unwrap() }); assert!(matches!( store @@ -236,7 +236,7 @@ impl Ready { self.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient(), + e.recipient().unwrap(), id.clone(), copy(&self.proof), ) @@ -255,7 +255,7 @@ impl Ready { self.binding.clone(), e.operation_id(), e.command_digest(), - e.recipient(), + e.recipient().unwrap(), id.clone(), copy(&self.proof), ) @@ -443,7 +443,7 @@ async fn predecessor_schema_six_preserves_original_installation_and_seal_without ready.store.close().await.unwrap(); let mut database = ready.fixture.database().await; sqlx::raw_sql("DROP TABLE chat_delivery_observations; DROP TABLE chat_delivery_parts; DROP TABLE chat_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 seal_evidence)").fetch_one(&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(); let path = ready.fixture.path.join("execution_v1.sqlite"); @@ -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 seal_evidence)").fetch_one(&mut database).await.unwrap(); + 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(); assert_eq!(counts, (0, 0, 1, 1)); sqlx::query("DROP TRIGGER refuse_delivery_part") .execute(&mut database) @@ -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(), + e.recipient().unwrap(), 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(), + e.recipient().unwrap(), id, copy(&ready.proof) ) diff --git a/crates/radroots/tests/support/receipt_delivery_admission.rs b/crates/radroots/tests/support/receipt_delivery_admission.rs @@ -69,7 +69,7 @@ async fn self_copy_delivery_refuses_the_original_peer_as_temporary_author() { } .sign_with_keys(&participant) .unwrap(); - let evidence = SealEvidence::verify(&claim, &signed.as_json(), None).unwrap(); + let evidence = ArtifactEvidence::verify(&claim, &signed.as_json(), None).unwrap(); assert!(matches!( ready .store @@ -113,7 +113,7 @@ async fn self_copy_delivery_refuses_the_original_peer_as_temporary_author() { let work = *snapshot .publications() .iter() - .find(|work| work.evidence().recipient() == key()) + .find(|work| work.recipient() == key()) .unwrap(); let peer = keys(2); let content = nostr::nips::nip44::encrypt( @@ -201,8 +201,7 @@ async fn self_copy_delivery_refuses_the_original_peer_as_temporary_author() { fn signed_candidate(ready: &Ready, scalar: u8, content: String) -> EnvelopeCandidate { let signer = keys(scalar); - let recipient = - nostr::PublicKey::from_slice(ready.work.evidence().recipient().as_bytes()).unwrap(); + let recipient = nostr::PublicKey::from_slice(ready.work.recipient().as_bytes()).unwrap(); let event = nostr::UnsignedEvent { id: None, pubkey: signer.public_key(), @@ -245,8 +244,7 @@ async fn rebound_work(ready: &Ready) -> PublicationWork { #[tokio::test] async fn native_delivery_independently_checks_temporary_keys_exact_seal_and_original_work() { let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 248).await; - let receiver = - nostr::PublicKey::from_slice(ready.work.evidence().recipient().as_bytes()).unwrap(); + let receiver = nostr::PublicKey::from_slice(ready.work.recipient().as_bytes()).unwrap(); let temp = keys(3); let wrong_plaintext = nostr::nips::nip44::encrypt( temp.secret_key(), @@ -395,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(), + e.recipient().unwrap(), DeliveryRequestId::parse(id).unwrap(), copy(&ready.proof) ) diff --git a/crates/radroots/tests/support/receipt_delivery_faults.rs b/crates/radroots/tests/support/receipt_delivery_faults.rs @@ -283,7 +283,7 @@ async fn a_fresh_delivery_deadline_after_first_issuance_expiry_reuses_original_b original.intent().deadline_unix_ms() ); let mut database = ready.fixture.database().await; - let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM signing_attempts),(SELECT count(*) FROM seal_evidence),(SELECT count(*) FROM chat_messages)").fetch_one(&mut database).await.unwrap(); + let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM signing_attempts),(SELECT count(*) FROM artifact_evidence),(SELECT count(*) FROM chat_messages)").fetch_one(&mut database).await.unwrap(); assert_eq!(counts, (1, 1, 1)); database.close().await.unwrap(); ready.store.close().await.unwrap(); diff --git a/crates/radroots/tests/support/receipt_installation.rs b/crates/radroots/tests/support/receipt_installation.rs @@ -95,9 +95,9 @@ async fn existing_peer_installation_allows_first_self_claim_within_original_wind assert_eq!(partial.publications().len(), 1); assert!( partial - .recipients() + .artifacts() .iter() - .find(|value| value.recipient() == key()) + .find(|value| value.recipient() == Ok(key())) .unwrap() .claim() .is_none() @@ -260,12 +260,12 @@ async fn actual_peer_installation_and_late_self_capture_keep_one_original_messag let peer_work = complete .publications() .iter() - .find(|value| value.evidence().recipient() == peer) + .find(|value| value.recipient() == peer) .unwrap(); let self_work = complete .publications() .iter() - .find(|value| value.evidence().recipient() == key()) + .find(|value| value.recipient() == key()) .unwrap(); assert_eq!(peer_work.transaction_id(), first.transaction_id()); assert_ne!(self_work.transaction_id(), first.transaction_id()); @@ -322,7 +322,7 @@ async fn actual_work_insert_failure_rolls_back_the_message_but_keeps_original_cl assert!(state.installation().is_none()); assert_eq!( state - .recipients() + .artifacts() .iter() .filter_map(|value| value.obtained()) .collect::<Vec<_>>(), @@ -406,7 +406,7 @@ async fn actual_t2_commit_uncertainty_latches_and_reopen_reconciles_original_obt assert!(state.installation().is_none()); assert_eq!( state - .recipients() + .artifacts() .iter() .filter_map(|value| value.obtained()) .collect::<Vec<_>>(), diff --git a/crates/radroots/tests/support/receipt_installation_refusal.rs b/crates/radroots/tests/support/receipt_installation_refusal.rs @@ -237,7 +237,7 @@ async fn installation_checks_original_scope_current_grant_and_transaction_clock_ assert!(state.installation().is_none()); assert_eq!( state - .recipients() + .artifacts() .iter() .filter_map(|value| value.obtained()) .collect::<Vec<_>>(), @@ -254,7 +254,7 @@ async fn installation_checks_original_scope_current_grant_and_transaction_clock_ .is_err() ); let mut database = fixture.database().await; - let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM chat_messages),(SELECT count(*) FROM chat_publication_work),(SELECT count(*) FROM seal_evidence)").fetch_one(&mut database).await.unwrap(); + let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM chat_messages),(SELECT count(*) FROM chat_publication_work),(SELECT count(*) FROM artifact_evidence)").fetch_one(&mut database).await.unwrap(); assert_eq!(counts, (0, 0, 1)); database.close().await.unwrap(); store.close().await.unwrap(); diff --git a/crates/radroots/tests/support/receipt_issuance.rs b/crates/radroots/tests/support/receipt_issuance.rs @@ -12,7 +12,7 @@ use radroots_signing::{ request::CancellationSignal, }; use radroots_storage::command::{ - ClaimAttemptOutcome, ClaimAttemptRequest, SealEvidence, SigningAttempt, + ArtifactEvidence, ClaimAttemptOutcome, ClaimAttemptRequest, SigningAttempt, }; thread_local! {static CALLS:Cell<usize>=const {Cell::new(0)};static MISSING:Cell<bool>=const {Cell::new(false)};} fn signer_clock() -> Result<u64, radroots_signing::Error> { @@ -90,7 +90,7 @@ pub(super) async fn prepare( let _ = fixture; (prepared, digest, recipients) } -pub(super) async fn obtain(attempt: &SigningAttempt, missing: bool) -> SealEvidence { +pub(super) async fn obtain(attempt: &SigningAttempt, missing: bool) -> ArtifactEvidence { CALLS.with(|calls| calls.set(0)); MISSING.with(|value| value.set(missing)); // Published synthetic key in a qualified local provider, isolated from all host custody. @@ -123,6 +123,6 @@ pub(super) async fn obtain(attempt: &SigningAttempt, missing: bool) -> SealEvide }; assert_eq!(artifact.observed_at_unix_ms().is_none(), missing); artifact.with_json(|raw| { - SealEvidence::verify(attempt, raw, artifact.observed_at_unix_ms()).unwrap() + ArtifactEvidence::verify(attempt, raw, artifact.observed_at_unix_ms()).unwrap() }) } diff --git a/crates/radroots/tests/support/receipt_recovery.rs b/crates/radroots/tests/support/receipt_recovery.rs @@ -8,7 +8,7 @@ struct Issued { proof: AttachmentProof, binding: WorkspaceBinding, attempt: SigningAttempt, - evidence: SealEvidence, + evidence: ArtifactEvidence, } impl Issued { async fn new(id: u8, large: bool) -> Self { @@ -28,7 +28,7 @@ impl Issued { let original = obtain(&attempt, true).await; let raw = format!(" \n{}\t", original.raw_json()); let evidence = - SealEvidence::verify(&attempt, &raw, original.observed_at_unix_ms()).unwrap(); + ArtifactEvidence::verify(&attempt, &raw, original.observed_at_unix_ms()).unwrap(); Self { fixture, store, @@ -65,7 +65,7 @@ async fn original_capture_recovery_retries_known_rollback_without_reissuing_and_ let issued = Issued::new(101, false).await; let original = issued.evidence.raw_json().to_owned(); let mut database = issued.fixture.database().await; - sqlx::query("CREATE TRIGGER capture_insert_fault BEFORE INSERT ON seal_evidence BEGIN SELECT RAISE(ABORT,'synthetic capture fault'); END").execute(&mut database).await.unwrap(); + sqlx::query("CREATE TRIGGER capture_insert_fault BEFORE INSERT ON artifact_evidence BEGIN SELECT RAISE(ABORT,'synthetic capture fault'); END").execute(&mut database).await.unwrap(); assert!( issued .store @@ -127,7 +127,7 @@ async fn unknown_capture_recovery_preserves_writer_during_refused_preflight_and_ let issued = Issued::new(102, true).await; let original = issued.evidence.raw_json().to_owned(); let mut database = issued.fixture.database().await; - sqlx::raw_sql("CREATE TABLE capture_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER capture_commit_fault_trigger AFTER INSERT ON seal_evidence BEGIN INSERT INTO capture_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TABLE capture_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER capture_commit_fault_trigger AFTER INSERT ON artifact_evidence BEGIN INSERT INTO capture_commit_fault VALUES(2); END").execute(&mut database).await.unwrap(); assert!(matches!( issued .store diff --git a/crates/radroots/tests/support/receipt_snapshots.rs b/crates/radroots/tests/support/receipt_snapshots.rs @@ -4,7 +4,7 @@ use radroots_execution::{ BusinessInstallation, Delivery, Issuance, OperationReceipt, RecoveryRequirement, WaitTermination, }; -use radroots_storage::command::{OperationSnapshot, RecipientSnapshot, RetainedOperation}; +use radroots_storage::command::{ArtifactSnapshot, OperationSnapshot, RetainedOperation}; #[tokio::test] async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation_evidence() { @@ -62,9 +62,9 @@ async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation .await .unwrap() .unwrap(); - let first = original.recipients()[0]; - let second = original.recipients()[1]; - let foreign = other.recipients()[0]; + let first = original.artifacts()[0]; + let second = original.artifacts()[1]; + let foreign = other.artifacts()[0]; let cases = [ (vec![], 100), (vec![first], 100), @@ -74,8 +74,8 @@ async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation (vec![first, second], 0), ( vec![ - RecipientSnapshot::from_store_report( - first.recipient(), + ArtifactSnapshot::from_store_report( + first.recipient().unwrap(), None, first.claim(), first.obtained(), @@ -86,8 +86,8 @@ async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation ), ( vec![ - RecipientSnapshot::from_store_report( - first.recipient(), + ArtifactSnapshot::from_store_report( + first.recipient().unwrap(), first.expected_event(), None, first.obtained(), @@ -98,8 +98,8 @@ async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation ), ( vec![ - RecipientSnapshot::from_store_report( - first.recipient(), + ArtifactSnapshot::from_store_report( + first.recipient().unwrap(), first.expected_event(), foreign.claim(), foreign.obtained(), @@ -110,8 +110,8 @@ async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation ), ( vec![ - RecipientSnapshot::from_store_report( - first.recipient(), + ArtifactSnapshot::from_store_report( + first.recipient().unwrap(), first.expected_event(), first.claim(), foreign.obtained(), @@ -154,7 +154,7 @@ async fn structural_reports_reject_incomplete_recipient_sets_and_cross_operation assert!(matches!( OperationSnapshot::from_store_report( RetainedOperation::Prepared(report), - original.recipients().to_vec(), + original.artifacts().to_vec(), UnixSeconds::new(100).unwrap() ), Err(OperationError::RecoveryRequired) @@ -352,7 +352,7 @@ async fn full_receipts_keep_obtained_and_unknown_recipients_separate_and_bind_or assert_eq!(original.obtained_digest(), Some(*first_bytes.digest())); assert_eq!( original.capture_transaction_id(), - snapshot.recipients()[0] + snapshot.artifacts()[0] .obtained() .map(|value| value.transaction_id()) ); @@ -453,10 +453,10 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap assert_eq!(receipt.authority_checkpoint(), binding.input().checkpoint()); let initial_checkpoint = receipt.operation_checkpoint(); assert_eq!(snapshot.message_id(), None); - assert_eq!(snapshot.recipients().len(), 2); + assert_eq!(snapshot.artifacts().len(), 2); assert!( snapshot - .recipients() + .artifacts() .iter() .all(|value| value.expected_event().is_none() && value.claim().is_none() @@ -486,12 +486,12 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap ); assert!( snapshot - .recipients() + .artifacts() .iter() .all(|value| value.expected_event().is_some() && value.claim().is_none()) ); - let first = snapshot.recipients()[0].recipient(); - let second = snapshot.recipients()[1].recipient(); + let first = snapshot.artifacts()[0].recipient().unwrap(); + let second = snapshot.artifacts()[1].recipient().unwrap(); let attempt = claim( store .claim_attempt( @@ -507,10 +507,10 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap .unwrap() .unwrap(); assert_eq!( - snapshot.recipients()[0].claim().unwrap().attempt_id(), + snapshot.artifacts()[0].claim().unwrap().attempt_id(), attempt.attempt_id() ); - assert!(snapshot.recipients()[0].obtained().is_none()); + assert!(snapshot.artifacts()[0].obtained().is_none()); let receipt = OperationReceipt::from_snapshot(&snapshot); assert_eq!(receipt.issuance(), Issuance::Unknown); assert_eq!(receipt.artifacts()[0].issuance(), Issuance::Unknown); @@ -524,7 +524,7 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap .recovery() .contains(&RecoveryRequirement::ReconcileIssuance) ); - assert!(snapshot.recipients()[1].claim().is_none()); + assert!(snapshot.artifacts()[1].claim().is_none()); let evidence = obtain(&attempt, true).await; let receipt = match store .capture_evidence(input.clone(), &proof, &evidence) @@ -539,7 +539,7 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap .await .unwrap() .unwrap(); - assert_eq!(snapshot.recipients()[0].obtained(), Some(receipt)); + assert_eq!(snapshot.artifacts()[0].obtained(), Some(receipt)); let view = OperationReceipt::from_snapshot(&snapshot); assert_eq!(view.issuance(), Issuance::Pending); assert_eq!(view.artifacts()[0].issuance(), Issuance::Obtained); @@ -570,14 +570,14 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap assert_eq!(stopped.delivery(), Delivery::NotStarted); assert!(stopped.durable()); assert_eq!( - snapshot.recipients()[0] + snapshot.artifacts()[0] .obtained() .unwrap() .observed_at_unix_ms(), None ); - assert_eq!(snapshot.recipients()[1].recipient(), second); - assert!(snapshot.recipients()[1].claim().is_none()); + assert_eq!(snapshot.artifacts()[1].recipient().unwrap(), second); + assert!(snapshot.artifacts()[1].claim().is_none()); assert_eq!(format!("{snapshot:?}"), "OperationSnapshot(<redacted>)"); store.close().await.unwrap(); fixture.clock.now.store(151, Ordering::SeqCst); @@ -589,11 +589,11 @@ async fn coherent_snapshots_retain_t0_t1_and_independent_recipient_claim_and_cap .unwrap(); assert_eq!(snapshot.prepared().identity(), prepared.identity()); assert_eq!(snapshot.message_id(), Some(message)); - assert_eq!(snapshot.recipients()[0].obtained(), Some(receipt)); + assert_eq!(snapshot.artifacts()[0].obtained(), Some(receipt)); let view = OperationReceipt::from_snapshot(&snapshot); assert_eq!(view.operation_checkpoint(), captured_checkpoint); assert_eq!(view.message_id(), Some(message)); - assert!(snapshot.recipients()[1].obtained().is_none()); + assert!(snapshot.artifacts()[1].obtained().is_none()); assert!(matches!( reopened .operation_snapshot( @@ -637,7 +637,7 @@ async fn complete_snapshot_rejects_extra_recipient_claims_and_orphan_parts_witho .unwrap(); let third = keys(3).public_key(); for number in 3u8..=12 { - sqlx::query("INSERT INTO signing_attempts(workspace,operation_id,recipient,attempt_id,transaction_id,plan_digest,intent_digest,protected) SELECT workspace,operation_id,?,?,?,plan_digest,intent_digest,protected FROM signing_attempts LIMIT 1") + sqlx::query("INSERT INTO signing_attempts(workspace,operation_id,artifact_key,attempt_id,transaction_id,plan_digest,intent_digest,protected) SELECT workspace,operation_id,?,?,?,plan_digest,intent_digest,protected FROM signing_attempts LIMIT 1") .bind(keys(number).public_key().as_bytes().as_slice()).bind([number;32].as_slice()).bind([number;32].as_slice()).execute(&mut database).await.unwrap(); } assert!(matches!( @@ -656,13 +656,13 @@ async fn complete_snapshot_rejects_extra_recipient_claims_and_orphan_parts_witho .await .unwrap(); assert_eq!(count, 11); - sqlx::query("DELETE FROM signing_attempts WHERE recipient!=?") + sqlx::query("DELETE FROM signing_attempts WHERE artifact_key!=?") .bind(recipients[0].as_bytes().as_slice()) .execute(&mut database) .await .unwrap(); for number in 3u8..=12 { - sqlx::query("INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,1,zeroblob(1))") + sqlx::query("INSERT INTO artifact_evidence_parts(workspace,operation_id,artifact_key,part,protected) VALUES(?,?,?,1,zeroblob(1))") .bind(binding.input().workspace_id().as_bytes().as_slice()).bind(prepared.identity().operation_id().as_bytes().as_slice()).bind(keys(number).public_key().as_bytes().as_slice()).execute(&mut database).await.unwrap(); } assert!(matches!( @@ -676,17 +676,17 @@ async fn complete_snapshot_rejects_extra_recipient_claims_and_orphan_parts_witho .await, Err(OperationError::RecoveryRequired) )); - let count: i64 = sqlx::query_scalar("SELECT count(*) FROM seal_evidence_parts") + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM artifact_evidence_parts") .fetch_one(&mut database) .await .unwrap(); assert_eq!(count, 10); - sqlx::query("DELETE FROM seal_evidence_parts") + sqlx::query("DELETE FROM artifact_evidence_parts") .execute(&mut database) .await .unwrap(); let missing = OperationId::from_bytes([237; 32]); - sqlx::query("INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,1,zeroblob(1))") + sqlx::query("INSERT INTO artifact_evidence_parts(workspace,operation_id,artifact_key,part,protected) VALUES(?,?,?,1,zeroblob(1))") .bind(binding.input().workspace_id().as_bytes().as_slice()).bind(missing.as_bytes().as_slice()).bind(third.as_bytes().as_slice()).execute(&mut database).await.unwrap(); assert!(matches!( store @@ -694,12 +694,12 @@ async fn complete_snapshot_rejects_extra_recipient_claims_and_orphan_parts_witho .await, Err(OperationError::RecoveryRequired) )); - let count: i64 = sqlx::query_scalar("SELECT count(*) FROM seal_evidence_parts") + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM artifact_evidence_parts") .fetch_one(&mut database) .await .unwrap(); assert_eq!(count, 1); - sqlx::query("DELETE FROM seal_evidence_parts") + sqlx::query("DELETE FROM artifact_evidence_parts") .execute(&mut database) .await .unwrap(); diff --git a/crates/radroots/tests/support/receipt_workflow.rs b/crates/radroots/tests/support/receipt_workflow.rs @@ -250,7 +250,7 @@ async fn ordinary_online_inquiry_runs_t0_t1_sign_install_and_exact_peer_self_del .unwrap(); assert!( snapshot - .recipients() + .artifacts() .iter() .all(|recipient| recipient.obtained().is_some()) ); 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().evidence().recipient(), + attempt.work().recipient(), attempt.intent().request_id().clone(), copy(&ready.proof), ) @@ -457,7 +457,7 @@ async fn uncertain_second_recipient_never_reissues_and_preserves_actual_first_co let snapshot = ready.snapshot(204).await; assert_eq!( snapshot - .recipients() + .artifacts() .iter() .filter(|recipient| recipient.obtained().is_some()) .count(), @@ -482,7 +482,7 @@ async fn failed_obtained_capture_blocks_close_retains_writer_and_retries_without let relay = Relay::new().await; let ready = Ready::new(&relay, StartMode::Online, RecordedSigner::new(None)).await; let mut db = ready.fixture.database().await; - sqlx::query("CREATE TRIGGER capture_insert_fault BEFORE INSERT ON seal_evidence BEGIN SELECT RAISE(ABORT, 'capture_insert_fault'); END").execute(&mut db).await.unwrap(); + sqlx::query("CREATE TRIGGER capture_insert_fault BEFORE INSERT ON artifact_evidence BEGIN SELECT RAISE(ABORT, 'capture_insert_fault'); END").execute(&mut db).await.unwrap(); let error = ready .client .inbox() @@ -517,7 +517,7 @@ async fn failed_obtained_capture_blocks_close_retains_writer_and_retries_without .unwrap(); assert_eq!( snapshot - .recipients() + .artifacts() .iter() .filter(|recipient| recipient.obtained().is_some()) .count(), @@ -537,7 +537,7 @@ async fn explicit_resume_recovers_unknown_capture_under_same_writer_before_conti .await .unwrap(); sqlx::query("CREATE TABLE capture_commit_fault (parent INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED)").execute(&mut db).await.unwrap(); - sqlx::query("CREATE TRIGGER capture_commit_fault AFTER INSERT ON seal_evidence BEGIN INSERT INTO capture_commit_fault(parent) VALUES(2); END").execute(&mut db).await.unwrap(); + sqlx::query("CREATE TRIGGER capture_commit_fault AFTER INSERT ON artifact_evidence BEGIN INSERT INTO capture_commit_fault(parent) VALUES(2); END").execute(&mut db).await.unwrap(); let error = ready .client .inbox() @@ -589,7 +589,7 @@ async fn explicit_resume_recovers_unknown_capture_under_same_writer_before_conti let snapshot = ready.snapshot(207).await; assert!( snapshot - .recipients() + .artifacts() .iter() .all(|recipient| recipient.obtained().is_some()) ); @@ -645,7 +645,7 @@ async fn lost_observer_and_cancelled_close_preserve_actual_obtained_signature_un .unwrap(); assert!( snapshot - .recipients() + .artifacts() .iter() .any(|recipient| recipient.obtained().is_some()) ); diff --git a/crates/radroots_browser/src/inquiry.rs b/crates/radroots_browser/src/inquiry.rs @@ -149,7 +149,7 @@ impl InquiryIo for BrowserInquiry { raw_seal: &str, ) -> Result<EnvelopeCandidate, OperationError> { let now = NonZeroU64::new(self.now()?.get()).ok_or(OperationError::RecoveryRequired)?; - let recipient = work.evidence().recipient(); + let recipient = work.recipient(); let wrapped = wrap_retained_seal(raw_seal, recipient, now, &BrowserNonceSource) .map_err(|_| OperationError::InvalidEvidence)?; wrapped.with_wrapping_key(|key| { diff --git a/crates/signing/Cargo.toml b/crates/signing/Cargo.toml @@ -33,6 +33,7 @@ name = "radroots_signing" [features] default = ["std", "serde"] chat = ["radroots_protocol/chat"] +artifacts = ["radroots_protocol/chat", "radroots_protocol/listing"] std = [ "radroots_domain/std", "radroots_event/std", diff --git a/crates/signing/src/issuance.rs b/crates/signing/src/issuance.rs @@ -6,7 +6,6 @@ use alloc::string::String; use core::{fmt, num::NonZeroU64}; use radroots_domain::OperationId; use radroots_event::{ - SignedEvent, id::EventId, wire::{EventWireLimits, Nip01EventWire}, }; @@ -38,18 +37,91 @@ pub use radroots_protocol::intent::{ArtifactRole, IntentBinding}; /// It has no automatic input-bearing diagnostics or serialization. pub struct SigningIntent { binding: IntentBinding, - plan: AuthoredEventPlan, + plan: ExactPreimage, role: ArtifactRole, recipient: Option<PublicKey>, call: ProviderCall, signed_json_bytes: usize, } +enum ExactPreimage { + Authored(AuthoredEventPlan), + #[cfg(feature = "artifacts")] + Listing(radroots_protocol::listing::ListingEvent), +} +impl ExactPreimage { + fn fields(&self) -> radroots_protocol::nip01::EventFields<'_> { + match self { + Self::Authored(plan) => radroots_protocol::nip01::EventFields { + author: *plan.author(), + created_at: plan.created_at(), + kind: plan.body().kind(), + tags: plan.body().tags(), + content: plan.body().content(), + }, + #[cfg(feature = "artifacts")] + Self::Listing(event) => event.fields(), + } + } + fn event_id(&self) -> radroots_event::id::EventId { + match self { + Self::Authored(plan) => *plan.expected_event_id(), + #[cfg(feature = "artifacts")] + Self::Listing(event) => radroots_event::id::EventId::from_bytes(*event.event_id()), + } + } +} impl fmt::Debug for SigningIntent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("SigningIntent(<redacted>)") } } impl SigningIntent { + /// Converts one exact retained-plan artifact to the existing signing port. + /// This verifies structural identity only; actual T1/first-claim commits, + /// current grant, destination policy and provider support remain required. + #[cfg(feature = "artifacts")] + pub fn from_plan( + plan: &radroots_protocol::plan::CapturedSigningPlan, + target: radroots_protocol::plan::SigningTarget, + call: ProviderCall, + ) -> Result<Self, ProviderError> { + use radroots_protocol::plan::SigningArtifact; + match plan + .artifact(target) + .map_err(|_| ProviderError::InvalidInput)? + { + SigningArtifact::Seal(seal) => { + Self::from_chat_seal(plan.operation_id(), plan.command_digest(), seal, call) + } + SigningArtifact::Public(event) => { + let fields = event.fields(); + if fields.author != call.identity() + || fields.created_at > MAX_EVENT_UNIX_SECONDS + || call.deadline_unix_ms().get() > MAX_OBSERVATION_UNIX_MS + { + return Err(ProviderError::InvalidInput); + } + let signed_json_bytes = signed_json_len(&fields, public_event_limits())?; + let binding = IntentBinding::from_components( + plan.operation_id(), + *plan.command_digest().as_bytes(), + *plan.digest(), + ArtifactRole::PublicEvent, + None, + call.deadline_unix_ms(), + ) + .map_err(|_| ProviderError::InvalidInput)?; + Ok(Self { + binding, + plan: ExactPreimage::Listing(event.clone()), + role: ArtifactRole::PublicEvent, + recipient: None, + call, + signed_json_bytes, + }) + } + } + } /// Freezes an already validated authored preimage and its captured context. /// Complete-event and parser budgets are checked without serializing or /// cloning the plan. A tighter business profile remains executor-owned. @@ -91,7 +163,16 @@ impl SigningIntent { if !role_valid { return Err(ProviderError::InvalidInput); } - let signed_json_bytes = signed_json_len(&plan)?; + let signed_json_bytes = signed_json_len( + &radroots_protocol::nip01::EventFields { + author: *plan.author(), + created_at: plan.created_at(), + kind: plan.body().kind(), + tags: plan.body().tags(), + content: plan.body().content(), + }, + EventWireLimits::default(), + )?; let binding = IntentBinding::from_components( operation_id, command_digest, @@ -103,7 +184,7 @@ impl SigningIntent { .map_err(|_| ProviderError::InvalidInput)?; Ok(Self { binding, - plan, + plan: ExactPreimage::Authored(plan), role, recipient, call, @@ -113,7 +194,7 @@ impl SigningIntent { /// Converts one bounded known-kind seal into the existing exact signer /// contract. This codec conversion grants no command, route or journal /// authority; the executor must retain the full plan before dispatch. - #[cfg(feature = "chat")] + #[cfg(any(feature = "chat", feature = "artifacts"))] pub fn from_chat_seal( operation_id: OperationId, command_digest: radroots_domain::CommandDigest, @@ -156,8 +237,8 @@ impl SigningIntent { self.signed_json_bytes } /// Returns the expected author, independently of any business actor claim. - pub const fn author(&self) -> PublicKey { - *self.plan.author() + pub fn author(&self) -> PublicKey { + self.plan.fields().author } /// Returns the exact artifact role. pub const fn role(&self) -> ArtifactRole { @@ -167,9 +248,16 @@ impl SigningIntent { pub const fn recipient(&self) -> Option<PublicKey> { self.recipient } - /// Exposes the bounded preimage only within an explicit host conversion. - pub fn with_plan<T>(&self, use_plan: impl FnOnce(&AuthoredEventPlan) -> T) -> T { - use_plan(&self.plan) + /// Borrows exact NIP-01 fields and ID for one concrete conversion. The + /// typed public profile does not pass through a predecessor generic registry. + pub fn with_event<T>( + &self, + use_event: impl FnOnce( + radroots_protocol::nip01::EventFields<'_>, + radroots_event::id::EventId, + ) -> T, + ) -> T { + use_event(self.plan.fields(), self.plan.event_id()) } /// Checks scheduling before effects. Never repeat this after obtaining bytes. pub fn check_before_effect( @@ -181,17 +269,19 @@ impl SigningIntent { } } -fn signed_json_len(plan: &AuthoredEventPlan) -> Result<usize, ProviderError> { - if plan.body().kind() > u32::from(u16::MAX) { +fn signed_json_len( + fields: &radroots_protocol::nip01::EventFields<'_>, + limits: EventWireLimits, +) -> Result<usize, ProviderError> { + if fields.kind > u32::from(u16::MAX) { return Err(ProviderError::UnsupportedVersion); } - let limits = EventWireLimits::default(); let mut elements = 0usize; let mut tag_bytes = 0usize; - if plan.body().tags().len() > limits.max_tag_count { + if fields.tags.len() > limits.max_tag_count { return Err(ProviderError::LimitExceeded); } - for tag in plan.body().tags() { + for tag in fields.tags { elements = elements .checked_add(tag.len()) .filter(|n| *n <= limits.max_total_tag_elements) @@ -206,17 +296,8 @@ fn signed_json_len(plan: &AuthoredEventPlan) -> Result<usize, ProviderError> { .ok_or(ProviderError::LimitExceeded)?; } } - radroots_protocol::nip01::signed_json_len( - &radroots_protocol::nip01::EventFields { - author: *plan.author(), - created_at: plan.created_at(), - kind: plan.body().kind(), - tags: plan.body().tags(), - content: plan.body().content(), - }, - SIGNED_EVENT_MAX_BYTES, - ) - .map_err(|_| ProviderError::LimitExceeded) + radroots_protocol::nip01::signed_json_len(fields, SIGNED_EVENT_MAX_BYTES) + .map_err(|_| ProviderError::LimitExceeded) } /// Scope of a forensic digest. A prefix digest never claims full coverage. @@ -357,29 +438,33 @@ impl SigningOutcome { if raw.len() > SIGNED_EVENT_MAX_BYTES { return reject(RejectionReason::TooLarge); } - let limits = EventWireLimits { - max_raw_json_bytes: SIGNED_EVENT_MAX_BYTES, - max_extra_fields: 0, - max_total_extra_json_bytes: 0, - ..EventWireLimits::default() + let limits = match &intent.plan { + #[cfg(feature = "artifacts")] + ExactPreimage::Listing(_) => public_event_limits(), + _ => EventWireLimits { + max_raw_json_bytes: SIGNED_EVENT_MAX_BYTES, + max_extra_fields: 0, + max_total_extra_json_bytes: 0, + ..EventWireLimits::default() + }, }; let Ok(wire) = Nip01EventWire::parse_json_exact_with_limits(&raw, limits) else { return reject(RejectionReason::InvalidArtifact); }; - let plan = &intent.plan; - if wire.pubkey != plan.author().to_hex() - || wire.created_at != plan.created_at() - || wire.kind != plan.body().kind() - || wire.tags != plan.body().tags() - || wire.content != plan.body().content() - || wire.id != plan.expected_event_id().to_hex() + let fields = intent.plan.fields(); + if wire.pubkey != fields.author.to_hex() + || wire.created_at != fields.created_at + || wire.kind != fields.kind + || wire.tags != fields.tags + || wire.content != fields.content + || wire.id != intent.plan.event_id().to_hex() { return reject(RejectionReason::InvalidArtifact); } - let Ok(event) = SignedEvent::from_wire_verified_id(wire, raw.as_str()) else { + let Ok(envelope) = checked_envelope(wire, limits) else { return reject(RejectionReason::InvalidArtifact); }; - let Ok(verified_id) = verify::id(RawEvent::new(event.envelope().clone())) else { + let Ok(verified_id) = verify::id(RawEvent::new(envelope)) else { return reject(RejectionReason::InvalidArtifact); }; if verify::signature(verified_id, &Nip01SignatureVerifier).is_err() { @@ -389,7 +474,7 @@ impl SigningOutcome { binding: intent.binding(), kind: OutcomeKind::Obtained(SignedArtifact { raw_json: raw, - event_id: *plan.expected_event_id(), + event_id: intent.plan.event_id(), observed_at_unix_ms: observed_at_unix_ms .filter(|at| at.get() <= MAX_OBSERVATION_UNIX_MS), }), @@ -429,3 +514,42 @@ impl SigningOutcome { } } } + +#[cfg(feature = "artifacts")] +fn public_event_limits() -> EventWireLimits { + EventWireLimits { + max_raw_json_bytes: SIGNED_EVENT_MAX_BYTES, + max_content_bytes: SIGNED_EVENT_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_EVENT_MAX_BYTES, + max_total_tag_bytes: SIGNED_EVENT_MAX_BYTES, + max_extra_fields: 0, + max_total_extra_json_bytes: 0, + } +} + +fn checked_envelope( + wire: Nip01EventWire, + limits: EventWireLimits, +) -> Result<radroots_event::envelope::EventEnvelope, radroots_event::envelope::EventEnvelopeError> { + use radroots_event::envelope::{EventEnvelope, EventEnvelopeLimits, EventEnvelopeParts}; + EventEnvelope::new_with_limits( + EventEnvelopeParts { + id: wire.id, + author: wire.pubkey, + created_at: wire.created_at, + kind: wire.kind, + tags: wire.tags, + content: wire.content, + sig: wire.sig, + }, + 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, + }, + ) +} diff --git a/crates/signing/tests/chat_seal.rs b/crates/signing/tests/chat_seal.rs @@ -108,14 +108,14 @@ fn known_kind_conversion_signs_and_authenticates_the_same_rumor_for_peer_and_sel intent .check_before_effect(rumor.author(), NOW * 1000) .unwrap(); - let event = intent.with_plan(|plan| { + let event = intent.with_event(|fields, event_id| { nostr::UnsignedEvent { - id: Some(nostr::EventId::from_slice(plan.expected_event_id().as_bytes()).unwrap()), + id: Some(nostr::EventId::from_slice(event_id.as_bytes()).unwrap()), pubkey: author.public_key(), - created_at: nostr::Timestamp::from_secs(plan.created_at()), - kind: nostr::Kind::Custom(plan.body().kind() as u16), + created_at: nostr::Timestamp::from_secs(fields.created_at), + kind: nostr::Kind::Custom(fields.kind as u16), tags: nostr::Tags::new(), - content: plan.body().content().into(), + content: fields.content.into(), } .sign_with_keys(&author) .unwrap() diff --git a/crates/signing/tests/issuance.rs b/crates/signing/tests/issuance.rs @@ -50,21 +50,21 @@ fn signed(intent: &SigningIntent) -> String { }) .unwrap(), ); - intent.with_plan(|plan| { + intent.with_event(|fields, event_id| { nostr::UnsignedEvent { - id: Some(nostr::EventId::from_slice(plan.expected_event_id().as_bytes()).unwrap()), + id: Some(nostr::EventId::from_slice(event_id.as_bytes()).unwrap()), pubkey: keys.public_key(), - created_at: nostr::Timestamp::from_secs(plan.created_at()), - kind: nostr::Kind::Custom(plan.body().kind() as u16), + created_at: nostr::Timestamp::from_secs(fields.created_at), + kind: nostr::Kind::Custom(fields.kind as u16), tags: nostr::Tags::from_list( - plan.body() - .tags() + fields + .tags .iter() .cloned() .map(|tag| nostr::Tag::parse(tag).unwrap()) .collect(), ), - content: plan.body().content().into(), + content: fields.content.into(), } .sign_with_keys(&keys) .unwrap() @@ -117,10 +117,7 @@ fn authenticated_bytes_survive_unknown_or_out_of_range_observation_and_never_ser panic!("valid artifact lost: {outcome:?}"); }; assert_eq!(artifact.with_json(str::to_owned), raw); - assert_eq!( - artifact.event_id(), - intent.with_plan(|plan| *plan.expected_event_id()) - ); + assert_eq!(artifact.event_id(), intent.with_event(|_, id| id)); assert_eq!( artifact.observed_at_unix_ms(), observed.filter(|at| at.get() <= MAX_EVENT_UNIX_SECONDS * 1000 + 999) diff --git a/crates/storage/src/command.rs b/crates/storage/src/command.rs @@ -9,7 +9,7 @@ use radroots_domain::{ }; pub use radroots_protocol::chat::ChatSigningPlan; use radroots_protocol::command::{CapturedChatCommand, CapturedCommand}; -pub use radroots_protocol::plan::CapturedSigningPlan; +pub use radroots_protocol::plan::{CapturedSigningPlan, SigningTarget}; use radroots_transport::BoxFuture; #[cfg(feature = "protected_outbox")] @@ -32,11 +32,11 @@ pub use installation::{ ChatInstallation, InstallationOutcome, InstallationRequest, PublicationWork, }; pub use issuance::{ - CapturedSeal, ClaimAttemptOutcome, ClaimAttemptRequest, EvidenceCaptureOutcome, - EvidenceReceipt, SealEvidence, SigningAttempt, + ArtifactEvidence, CapturedArtifact, ClaimAttemptOutcome, ClaimAttemptRequest, + EvidenceCaptureOutcome, EvidenceReceipt, SigningAttempt, }; pub use observation::{DeliveryObservation, DeliveryObservationKind, DeliveryObservationOutcome}; -pub use snapshot::{ClaimSnapshot, OperationSnapshot, RecipientSnapshot, RetainedOperation}; +pub use snapshot::{ArtifactSnapshot, ClaimSnapshot, OperationSnapshot, RetainedOperation}; /// Fixed operation-store failures known before a successful admission commit. #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -320,7 +320,7 @@ pub trait OperationJournal: WorkspaceStore { &'a self, _input: crate::workspace::AttachmentInput, _proof: &'a AttachmentProof, - _evidence: &'a SealEvidence, + _evidence: &'a ArtifactEvidence, ) -> BoxFuture<'a, Result<EvidenceCaptureOutcome, OperationError>> { Box::pin(async { Err(OperationError::RecoveryRequired) }) } @@ -401,14 +401,14 @@ pub trait OperationJournal: WorkspaceStore { &'a self, input: crate::workspace::AttachmentInput, proof: &'a AttachmentProof, - evidence: &'a SealEvidence, + evidence: &'a ArtifactEvidence, ) -> BoxFuture<'a, Result<EvidenceCaptureOutcome, OperationError>>; /// Reads original exact captured bytes under current workspace access. fn obtained_evidence( &self, request: ClaimAttemptRequest, proof: AttachmentProof, - ) -> BoxFuture<'_, Result<Option<CapturedSeal>, OperationError>>; + ) -> BoxFuture<'_, Result<Option<CapturedArtifact>, OperationError>>; /// Atomically retains the complete immutable plan under current access and /// the original first-issue window. No signer invocation happens here. fn bind_signing_intents( diff --git a/crates/storage/src/command/delivery.rs b/crates/storage/src/command/delivery.rs @@ -72,7 +72,7 @@ impl EnvelopeCandidate { raw: &str, wrapping_key: &[u8; 32], ) -> Result<Self, OperationError> { - let carrier = outer(raw, work.evidence().recipient())?; + let carrier = outer(raw, work.recipient())?; Ok(Self { work, event: EnvelopeEventId::from_bytes(*carrier.envelope().id().as_bytes()), @@ -383,7 +383,7 @@ impl DeliveryAttempt { retained_at: UnixSeconds, ordinals: Vec<u8>, ) -> Result<Self, OperationError> { - let event = outer(raw, work.evidence().recipient())?; + let event = outer(raw, work.recipient())?; if event.envelope().id().as_bytes() != intent.event_id().as_bytes() || retained_at < work.queued_at() || event.envelope().created_at_u64() > retained_at.get() @@ -439,7 +439,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.evidence().recipient())?; + let event = outer(self.raw_json(), self.work.recipient())?; DeliveryRequest::new( self.intent.request_id().as_str(), DeliveryPayload::new(event), diff --git a/crates/storage/src/command/installation.rs b/crates/storage/src/command/installation.rs @@ -152,6 +152,7 @@ impl fmt::Debug for ChatInstallation { /// a signed outer envelope nor a transport acknowledgement. #[derive(Clone, Copy, Eq, PartialEq)] pub struct PublicationWork { + recipient: radroots_domain::PublicKey, installation: TransactionId, plan: [u8; 32], evidence: EvidenceReceipt, @@ -181,6 +182,7 @@ impl PublicationWork { return Err(OperationError::RecoveryRequired); } Ok(Self { + recipient: evidence.recipient()?, installation: installation.transaction_id(), plan: *bound.plan().digest(), evidence, @@ -196,6 +198,10 @@ impl PublicationWork { pub const fn plan_digest(&self) -> &[u8; 32] { &self.plan } + /// Actual private participant validated against the retained plan. + pub const fn recipient(&self) -> radroots_domain::PublicKey { + self.recipient + } /// Exact recipient, seal and protected capture reference. pub const fn evidence(&self) -> EvidenceReceipt { self.evidence @@ -241,7 +247,7 @@ fn check_evidence( .chat_plan()? .seals() .iter() - .find(|seal| seal.recipient() == evidence.recipient()) + .find(|seal| Some(seal.recipient()) == evidence.target().recipient()) .ok_or(OperationError::RecoveryRequired)?; if evidence.workspace_id() != identity.workspace_id() || evidence.operation_id() != identity.operation_id() diff --git a/crates/storage/src/command/issuance.rs b/crates/storage/src/command/issuance.rs @@ -1,4 +1,4 @@ -//! Exact attempt and independently verified obtained-seal data. Constructors +//! Exact attempt and independently verified obtained-artifact data. Constructors //! provide no proof that a backend retained a claim or authorized dispatch. use super::{BoundSigningPlan, CommitAttempt, OperationError}; use crate::workspace::WorkspaceBinding; @@ -8,7 +8,7 @@ use radroots_domain::{ UnixSeconds, WorkspaceId, }; use radroots_event::{ - GenericEventDraft, SignedEvent, + GenericEventDraft, wire::{EventWireLimits, Nip01EventWire}, }; use radroots_event_codec::{ @@ -17,7 +17,8 @@ use radroots_event_codec::{ }; use radroots_protocol::{ chat::ChatSeal, - intent::{ArtifactRole, IntentBinding}, + intent::IntentBinding, + plan::{SigningArtifact, SigningTarget}, }; use sha2::{Digest, Sha256}; use zeroize::Zeroizing; @@ -29,7 +30,7 @@ pub struct ClaimAttemptRequest { operation_id: OperationId, command_digest: CommandDigest, plan_digest: [u8; 32], - recipient: PublicKey, + target: SigningTarget, } impl ClaimAttemptRequest { pub const fn new( @@ -39,12 +40,27 @@ impl ClaimAttemptRequest { plan_digest: [u8; 32], recipient: PublicKey, ) -> Self { + Self::for_artifact( + binding, + operation_id, + command_digest, + plan_digest, + SigningTarget::BusinessSeal(recipient), + ) + } + pub const fn for_artifact( + binding: WorkspaceBinding, + operation_id: OperationId, + command_digest: CommandDigest, + plan_digest: [u8; 32], + target: SigningTarget, + ) -> Self { Self { binding, operation_id, command_digest, plan_digest, - recipient, + target, } } pub const fn binding(&self) -> &WorkspaceBinding { @@ -59,8 +75,14 @@ impl ClaimAttemptRequest { pub const fn plan_digest(&self) -> &[u8; 32] { &self.plan_digest } - pub const fn recipient(&self) -> PublicKey { - self.recipient + pub const fn target(&self) -> SigningTarget { + self.target + } + /// Private-only projection; a public artifact has no recipient. + pub fn recipient(&self) -> Result<PublicKey, OperationError> { + self.target + .recipient() + .ok_or(OperationError::UnsupportedOperation) } pub fn identity(&self) -> CommitAttempt { CommitAttempt::new( @@ -82,7 +104,7 @@ impl fmt::Debug for ClaimAttemptRequest { /// retrieving this snapshot never proves a previous invocation did not begin. pub struct SigningAttempt { bound: BoundSigningPlan, - recipient_index: usize, + target: SigningTarget, attempt_id: SigningAttemptId, transaction_id: TransactionId, claimed_at: UnixSeconds, @@ -92,7 +114,7 @@ pub struct SigningAttempt { impl SigningAttempt { pub fn from_committed_store( bound: BoundSigningPlan, - recipient: PublicKey, + target: impl Into<SigningTarget>, attempt_id: SigningAttemptId, transaction_id: TransactionId, claimed_at: UnixSeconds, @@ -101,13 +123,16 @@ impl SigningAttempt { if claimed_at < bound.bound_at() || claimed_at >= window.first_issue_not_after() { return Err(OperationError::RecoveryRequired); } - let recipient_index = bound - .chat_plan()? - .seals() - .iter() - .position(|seal| seal.recipient() == recipient) - .ok_or(OperationError::InvalidCommand)?; - let seal = &bound.chat_plan()?.seals()[recipient_index]; + let target = target.into(); + if matches!(target, SigningTarget::PublicEvent) && bound.plan().listing().is_none() + || matches!(target, SigningTarget::BusinessSeal(_)) && bound.plan().chat().is_none() + { + return Err(OperationError::UnsupportedOperation); + } + let artifact = bound + .plan() + .artifact(target) + .map_err(|_| OperationError::InvalidCommand)?; let deadline = NonZeroU64::new( window .first_issue_not_after() @@ -116,36 +141,42 @@ impl SigningAttempt { .ok_or(OperationError::RecoveryRequired)?, ) .ok_or(OperationError::RecoveryRequired)?; - let fields = seal.fields(); - // Internal reuse of the qualified v1 authored-plan hash. No predecessor - // event model escapes this new API; downward parser retirement remains - // separately governed by the shared target architecture. - let draft = GenericEventDraft::new( - "radroots.message.seal.v1", - fields.kind, - fields.created_at, - Vec::new(), - fields.content, - fields.author.to_hex(), - ) - .map_err(|_| OperationError::InvalidCommand)?; - let plan = - AuthoredEventPlan::from_generic(draft).map_err(|_| OperationError::InvalidCommand)?; - if plan.expected_event_id().as_bytes() != &seal.event_id() { - return Err(OperationError::RecoveryRequired); - } + let preimage_digest = match target { + SigningTarget::PublicEvent => *bound.plan().digest(), + SigningTarget::BusinessSeal(_) => { + let fields = artifact.fields(); + // Internal reuse of the qualified v1 authored-plan hash. No predecessor + // event model escapes this new API; downward parser retirement remains + // separately governed by the shared target architecture. + let draft = GenericEventDraft::new( + "radroots.message.seal.v1", + fields.kind, + fields.created_at, + fields.tags.to_vec(), + fields.content, + fields.author.to_hex(), + ) + .map_err(|_| OperationError::InvalidCommand)?; + let plan = AuthoredEventPlan::from_generic(draft) + .map_err(|_| OperationError::InvalidCommand)?; + if plan.expected_event_id().as_bytes() != &artifact.event_id() { + return Err(OperationError::RecoveryRequired); + } + *plan.digest().as_bytes() + } + }; let binding = IntentBinding::from_components( - seal.operation_id(), - *seal.command_digest().as_bytes(), - *plan.digest().as_bytes(), - ArtifactRole::BusinessSeal, - Some(recipient), + bound.plan().operation_id(), + *bound.plan().command_digest().as_bytes(), + preimage_digest, + target.role(), + target.recipient(), deadline, ) .map_err(|_| OperationError::InvalidCommand)?; Ok(Self { bound, - recipient_index, + target, attempt_id, transaction_id, claimed_at, @@ -160,14 +191,22 @@ impl SigningAttempt { pub const fn bound_plan(&self) -> &BoundSigningPlan { &self.bound } - /// Borrows the exact retained seal. The private index is validated once - /// against the immutable complete plan by the structural constructor. - pub fn seal(&self) -> Result<&ChatSeal, OperationError> { + /// Exact retained artifact, with no private projection for public events. + pub fn artifact(&self) -> Result<SigningArtifact<'_>, OperationError> { self.bound - .chat_plan()? - .seals() - .get(self.recipient_index) - .ok_or(OperationError::RecoveryRequired) + .plan() + .artifact(self.target) + .map_err(|_| OperationError::RecoveryRequired) + } + pub const fn target(&self) -> SigningTarget { + self.target + } + /// Borrows a private seal only when this attempt actually selected one. + pub fn seal(&self) -> Result<&ChatSeal, OperationError> { + match self.artifact()? { + SigningArtifact::Seal(seal) => Ok(seal), + _ => Err(OperationError::UnsupportedOperation), + } } pub const fn attempt_id(&self) -> SigningAttemptId { self.attempt_id @@ -224,12 +263,12 @@ impl fmt::Debug for ClaimAttemptOutcome { /// Independently authenticated exact obtained bytes, bound to reported claim /// data but not proof of the backend's actual retained attempt. Concrete capture /// must compare its own protected claim and plan before appending this evidence. -pub struct SealEvidence { +pub struct ArtifactEvidence { workspace_id: WorkspaceId, operation_id: OperationId, command_digest: CommandDigest, plan_digest: [u8; 32], - recipient: PublicKey, + target: SigningTarget, attempt_id: SigningAttemptId, intent: IntentBinding, event_id: EnvelopeEventId, @@ -237,7 +276,7 @@ pub struct SealEvidence { digest: [u8; 32], observed_at: Option<NonZeroU64>, } -impl SealEvidence { +impl ArtifactEvidence { /// Bounds before copying and verifies ID/signature/every signed field. /// No clock, grant-expiry or cancellation lookup may discard obtained bytes. pub fn verify( @@ -248,17 +287,31 @@ impl SealEvidence { if raw.len() > 65536 { return Err(OperationError::InvalidEvidence); } - let limits = EventWireLimits { - max_raw_json_bytes: 65536, - max_extra_fields: 0, - max_total_extra_json_bytes: 0, - ..EventWireLimits::default() + let limits = if attempt.target() == SigningTarget::PublicEvent { + EventWireLimits { + max_raw_json_bytes: 65536, + max_content_bytes: 65536, + 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: 65536, + max_total_tag_bytes: 65536, + max_extra_fields: 0, + max_total_extra_json_bytes: 0, + } + } else { + EventWireLimits { + max_raw_json_bytes: 65536, + max_extra_fields: 0, + max_total_extra_json_bytes: 0, + ..EventWireLimits::default() + } }; let wire = Nip01EventWire::parse_json_exact_with_limits(raw, limits) .map_err(|_| OperationError::InvalidEvidence)?; - let seal = attempt.seal()?; - let fields = seal.fields(); - let event_id = EnvelopeEventId::from_bytes(seal.event_id()); + let artifact = attempt.artifact()?; + let fields = artifact.fields(); + let event_id = EnvelopeEventId::from_bytes(artifact.event_id()); if wire.id != event_id.to_string() || wire.pubkey != fields.author.to_hex() || wire.kind != fields.kind @@ -268,10 +321,10 @@ impl SealEvidence { { return Err(OperationError::InvalidEvidence); } - let event = SignedEvent::from_wire_verified_id(wire, raw) - .map_err(|_| OperationError::InvalidEvidence)?; - let id = verify::id(RawEvent::new(event.envelope().clone())) - .map_err(|_| OperationError::InvalidEvidence)?; + let envelope = + checked_envelope(wire, limits).map_err(|_| OperationError::InvalidEvidence)?; + let id = + verify::id(RawEvent::new(envelope)).map_err(|_| OperationError::InvalidEvidence)?; verify::signature(id, &Nip01SignatureVerifier) .map_err(|_| OperationError::InvalidEvidence)?; let original = attempt.bound_plan().prepared().identity(); @@ -280,7 +333,7 @@ impl SealEvidence { operation_id: original.operation_id(), command_digest: original.command_digest(), plan_digest: *attempt.bound_plan().plan().digest(), - recipient: seal.recipient(), + target: attempt.target(), attempt_id: attempt.attempt_id(), intent: attempt.binding(), event_id, @@ -297,7 +350,7 @@ impl SealEvidence { operation_id: self.operation_id, command_digest: self.command_digest, plan_digest: self.plan_digest, - recipient: self.recipient, + target: self.target, attempt_id: self.attempt_id, intent: self.intent, event_id: self.event_id, @@ -307,7 +360,7 @@ impl SealEvidence { } } pub fn matches_attempt(&self, attempt: &SigningAttempt) -> bool { - let Ok(seal) = attempt.seal() else { + let Ok(artifact) = attempt.artifact() else { return false; }; self.workspace_id == attempt.bound_plan().prepared().identity().workspace_id() @@ -316,8 +369,8 @@ impl SealEvidence { && self.operation_id == attempt.bound_plan().prepared().identity().operation_id() && self.command_digest == attempt.bound_plan().prepared().identity().command_digest() && &self.plan_digest == attempt.bound_plan().plan().digest() - && self.recipient == seal.recipient() - && self.event_id.as_bytes() == &seal.event_id() + && self.target == attempt.target() + && self.event_id.as_bytes() == &artifact.event_id() } pub const fn workspace_id(&self) -> WorkspaceId { self.workspace_id @@ -331,8 +384,14 @@ impl SealEvidence { pub const fn plan_digest(&self) -> &[u8; 32] { &self.plan_digest } - pub const fn recipient(&self) -> PublicKey { - self.recipient + pub const fn target(&self) -> SigningTarget { + self.target + } + /// Private-only projection; a public artifact has no recipient. + pub fn recipient(&self) -> Result<PublicKey, OperationError> { + self.target + .recipient() + .ok_or(OperationError::UnsupportedOperation) } pub const fn attempt_id(&self) -> SigningAttemptId { self.attempt_id @@ -353,9 +412,9 @@ impl SealEvidence { self.observed_at } } -impl fmt::Debug for SealEvidence { +impl fmt::Debug for ArtifactEvidence { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str("SealEvidence(<redacted>)") + f.write_str("ArtifactEvidence(<redacted>)") } } @@ -367,7 +426,7 @@ pub struct EvidenceReceipt { operation_id: OperationId, command_digest: CommandDigest, attempt_id: SigningAttemptId, - recipient: PublicKey, + target: SigningTarget, event_id: EnvelopeEventId, digest: [u8; 32], transaction_id: TransactionId, @@ -375,7 +434,7 @@ pub struct EvidenceReceipt { } impl EvidenceReceipt { pub const fn from_committed_store( - evidence: &SealEvidence, + evidence: &ArtifactEvidence, transaction_id: TransactionId, ) -> Self { Self { @@ -383,7 +442,7 @@ impl EvidenceReceipt { operation_id: evidence.operation_id, command_digest: evidence.command_digest, attempt_id: evidence.attempt_id, - recipient: evidence.recipient, + target: evidence.target, event_id: evidence.event_id, digest: evidence.digest, transaction_id, @@ -402,8 +461,14 @@ impl EvidenceReceipt { pub const fn attempt_id(&self) -> SigningAttemptId { self.attempt_id } - pub const fn recipient(&self) -> PublicKey { - self.recipient + pub const fn target(&self) -> SigningTarget { + self.target + } + /// Private-only projection; a public artifact has no recipient. + pub fn recipient(&self) -> Result<PublicKey, OperationError> { + self.target + .recipient() + .ok_or(OperationError::UnsupportedOperation) } pub const fn event_id(&self) -> EnvelopeEventId { self.event_id @@ -426,15 +491,15 @@ pub enum EvidenceCaptureOutcome { } /// An original protected obtained record read under current workspace access. /// Advanced adapter construction remains a structural report, not qualification. -pub struct CapturedSeal { +pub struct CapturedArtifact { attempt: SigningAttempt, - evidence: SealEvidence, + evidence: ArtifactEvidence, receipt: EvidenceReceipt, } -impl CapturedSeal { +impl CapturedArtifact { pub fn from_committed_store( attempt: SigningAttempt, - evidence: SealEvidence, + evidence: ArtifactEvidence, transaction_id: TransactionId, ) -> Result<Self, OperationError> { if !evidence.matches_attempt(&attempt) { @@ -450,15 +515,40 @@ impl CapturedSeal { pub const fn attempt(&self) -> &SigningAttempt { &self.attempt } - pub const fn evidence(&self) -> &SealEvidence { + pub const fn evidence(&self) -> &ArtifactEvidence { &self.evidence } pub const fn receipt(&self) -> EvidenceReceipt { self.receipt } } -impl fmt::Debug for CapturedSeal { +impl fmt::Debug for CapturedArtifact { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str("CapturedSeal(<redacted>)") + f.write_str("CapturedArtifact(<redacted>)") } } + +fn checked_envelope( + wire: Nip01EventWire, + limits: EventWireLimits, +) -> Result<radroots_event::envelope::EventEnvelope, radroots_event::envelope::EventEnvelopeError> { + use radroots_event::envelope::{EventEnvelope, EventEnvelopeLimits, EventEnvelopeParts}; + EventEnvelope::new_with_limits( + EventEnvelopeParts { + id: wire.id, + author: wire.pubkey, + created_at: wire.created_at, + kind: wire.kind, + tags: wire.tags, + content: wire.content, + sig: wire.sig, + }, + 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, + }, + ) +} diff --git a/crates/storage/src/command/protected/issuance.rs b/crates/storage/src/command/protected/issuance.rs @@ -1,12 +1,13 @@ //! Opaque original claim and obtained-evidence metadata for protecting hosts. //! Decoding supplies no current access, actual commit or dispatch permission. use super::plan::PART_BYTES; -use crate::command::{BoundSigningPlan, OperationError, SealEvidence, SigningAttempt}; +use crate::command::{ArtifactEvidence, BoundSigningPlan, OperationError, SigningAttempt}; use core::num::NonZeroU64; use radroots_domain::{ CommandDigest, EnvelopeEventId, GrantId, OperationId, PublicKey, SigningAttemptId, TransactionId, UnixSeconds, WorkspaceId, }; +use radroots_protocol::plan::SigningTarget; use serde::{Deserialize, Serialize}; use zeroize::Zeroizing; @@ -18,7 +19,14 @@ struct ClaimWire { operation_id: OperationId, command_digest: CommandDigest, plan_digest: [u8; 32], - recipient: PublicKey, + #[serde(deserialize_with = "required_recipient")] + recipient: Option<PublicKey>, + #[serde( + default, + skip_serializing_if = "Option::is_none", + deserialize_with = "present_role" + )] + role: Option<u8>, attempt_id: SigningAttemptId, transaction_id: TransactionId, claimed_at: UnixSeconds, @@ -35,12 +43,13 @@ impl ClaimWire { let prepared = plan.prepared(); let identity = prepared.identity(); Ok(Self { - version: 1, + version: version(attempt.target()), workspace: identity.workspace_id(), operation_id: identity.operation_id(), command_digest: identity.command_digest(), plan_digest: *plan.plan().digest(), - recipient: attempt.seal()?.recipient(), + recipient: attempt.target().recipient(), + role: role(attempt.target()), attempt_id: attempt.attempt_id(), transaction_id: attempt.transaction_id(), claimed_at: attempt.claimed_at(), @@ -49,7 +58,7 @@ impl ClaimWire { preparation_transaction: prepared.transaction_id(), plan_transaction: plan.transaction_id(), grant_id: prepared.request().binding().input().grant_id(), - expected_event: EnvelopeEventId::from_bytes(attempt.seal()?.event_id()), + expected_event: EnvelopeEventId::from_bytes(attempt.artifact()?.event_id()), }) } } @@ -66,7 +75,7 @@ impl ClaimRecord { pub fn decode( raw: &[u8], bound: BoundSigningPlan, - recipient: PublicKey, + target: impl Into<SigningTarget>, ) -> Result<SigningAttempt, OperationError> { if raw.len() > PART_BYTES { return Err(OperationError::RecoveryRequired); @@ -75,7 +84,7 @@ impl ClaimRecord { serde_json::from_slice(raw).map_err(|_| OperationError::RecoveryRequired)?; let attempt = SigningAttempt::from_committed_store( bound, - recipient, + target, wire.attempt_id, wire.transaction_id, wire.claimed_at, @@ -94,7 +103,14 @@ struct EvidenceWire { operation_id: OperationId, command_digest: CommandDigest, plan_digest: [u8; 32], - recipient: PublicKey, + #[serde(deserialize_with = "required_recipient")] + recipient: Option<PublicKey>, + #[serde( + default, + skip_serializing_if = "Option::is_none", + deserialize_with = "present_role" + )] + role: Option<u8>, attempt_id: SigningAttemptId, claim_transaction: TransactionId, intent_digest: [u8; 32], @@ -111,19 +127,20 @@ pub struct EvidenceManifest(EvidenceWire); impl EvidenceManifest { pub fn capture( attempt: &SigningAttempt, - evidence: &SealEvidence, + evidence: &ArtifactEvidence, transaction: TransactionId, ) -> Result<Self, OperationError> { if !evidence.matches_attempt(attempt) { return Err(OperationError::InvalidEvidence); } let result = Self(EvidenceWire { - version: 1, + version: version(evidence.target()), workspace: evidence.workspace_id(), operation_id: evidence.operation_id(), command_digest: evidence.command_digest(), plan_digest: *evidence.plan_digest(), - recipient: evidence.recipient(), + recipient: evidence.target().recipient(), + role: role(evidence.target()), attempt_id: evidence.attempt_id(), claim_transaction: attempt.transaction_id(), intent_digest: *evidence.intent().digest(), @@ -153,16 +170,17 @@ impl EvidenceManifest { let w = &self.0; let bound = attempt.bound_plan(); let identity = bound.prepared().identity(); - if w.version != 1 + if w.version != version(attempt.target()) + || w.role != role(attempt.target()) || w.workspace != identity.workspace_id() || w.operation_id != identity.operation_id() || w.command_digest != identity.command_digest() || &w.plan_digest != bound.plan().digest() - || w.recipient != attempt.seal()?.recipient() + || w.recipient != attempt.target().recipient() || w.attempt_id != attempt.attempt_id() || w.claim_transaction != attempt.transaction_id() || &w.intent_digest != attempt.binding().digest() - || w.event_id.as_bytes() != &attempt.seal()?.event_id() + || w.event_id.as_bytes() != &attempt.artifact()?.event_id() || !(1..=65536).contains(&w.byte_count) || !(1..=4).contains(&w.part_count) || w.byte_count.div_ceil(PART_BYTES) != w.part_count @@ -195,13 +213,13 @@ impl EvidenceManifest { &self, attempt: &SigningAttempt, raw: &str, - ) -> Result<SealEvidence, OperationError> { + ) -> Result<ArtifactEvidence, OperationError> { self.validate(attempt)?; if raw.len() != self.byte_count() { return Err(OperationError::RecoveryRequired); } let evidence = - SealEvidence::verify(attempt, raw, self.0.observed_at.and_then(NonZeroU64::new)) + ArtifactEvidence::verify(attempt, raw, self.0.observed_at.and_then(NonZeroU64::new)) .map_err(|_| OperationError::RecoveryRequired)?; if evidence.digest() != self.evidence_digest() { return Err(OperationError::RecoveryRequired); @@ -217,3 +235,26 @@ fn encode(value: &impl Serialize) -> Result<Zeroizing<Vec<u8>>, OperationError> } Ok(raw) } + +// Private v1 bytes remain unchanged. Public v2 explicitly carries role 0 and a +// required null recipient; omitted/null roles never masquerade as public data. +fn version(target: SigningTarget) -> u8 { + match target { + SigningTarget::PublicEvent => 2, + SigningTarget::BusinessSeal(_) => 1, + } +} +fn role(target: SigningTarget) -> Option<u8> { + match target { + SigningTarget::PublicEvent => Some(0), + SigningTarget::BusinessSeal(_) => None, + } +} +fn required_recipient<'de, D: serde::Deserializer<'de>>( + d: D, +) -> Result<Option<PublicKey>, D::Error> { + Option::<PublicKey>::deserialize(d) +} +fn present_role<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Option<u8>, D::Error> { + u8::deserialize(d).map(Some) +} diff --git a/crates/storage/src/command/snapshot.rs b/crates/storage/src/command/snapshot.rs @@ -9,7 +9,7 @@ use radroots_domain::{ ChatMessage, ChatRelation, CommandDigest, EnvelopeEventId, MessageId, OperationId, PublicKey, SigningAttemptId, TransactionId, UnixSeconds, WorkspaceId, }; -use radroots_protocol::intent::IntentBinding; +use radroots_protocol::{intent::IntentBinding, plan::SigningTarget}; use sha2::{Digest, Sha256}; use std::{ boxed::Box, @@ -18,14 +18,14 @@ use std::{ vec::Vec, }; -/// Fixed original claim facts, without another copy of its complete private plan. +/// Fixed original claim facts, without another copy of its complete plan. #[derive(Clone, Copy, Eq, PartialEq)] pub struct ClaimSnapshot { workspace: WorkspaceId, operation: OperationId, command: CommandDigest, plan: [u8; 32], - recipient: PublicKey, + target: SigningTarget, attempt: SigningAttemptId, transaction: TransactionId, claimed_at: UnixSeconds, @@ -42,11 +42,11 @@ impl ClaimSnapshot { operation: identity.operation_id(), command: identity.command_digest(), plan: *attempt.bound_plan().plan().digest(), - recipient: attempt.seal()?.recipient(), + target: attempt.target(), attempt: attempt.attempt_id(), transaction: attempt.transaction_id(), claimed_at: attempt.claimed_at(), - event: EnvelopeEventId::from_bytes(attempt.seal()?.event_id()), + event: EnvelopeEventId::from_bytes(attempt.artifact()?.event_id()), intent: attempt.binding(), }) } @@ -67,8 +67,13 @@ impl ClaimSnapshot { &self.plan } /// Exact intended recipient. - pub const fn recipient(self) -> PublicKey { - self.recipient + pub const fn target(self) -> SigningTarget { + self.target + } + pub fn recipient(self) -> Result<PublicKey, OperationError> { + self.target + .recipient() + .ok_or(OperationError::UnsupportedOperation) } /// Full-width retained attempt identity. pub const fn attempt_id(self) -> SigningAttemptId { @@ -97,33 +102,38 @@ impl fmt::Debug for ClaimSnapshot { } } -/// One expected recipient's independent retained facts. Absence of obtained +/// One exact artifact's independent retained facts. Absence of obtained /// evidence for a retained claim never establishes safe reissue. #[derive(Clone, Copy, Eq, PartialEq)] -pub struct RecipientSnapshot { - recipient: PublicKey, +pub struct ArtifactSnapshot { + target: SigningTarget, expected_event: Option<EnvelopeEventId>, claim: Option<ClaimSnapshot>, obtained: Option<EvidenceReceipt>, } -impl RecipientSnapshot { +impl ArtifactSnapshot { /// Structural report; the complete snapshot constructor checks its scope. - pub const fn from_store_report( - recipient: PublicKey, + pub fn from_store_report( + target: impl Into<SigningTarget>, expected_event: Option<EnvelopeEventId>, claim: Option<ClaimSnapshot>, obtained: Option<EvidenceReceipt>, ) -> Self { Self { - recipient, + target: target.into(), expected_event, claim, obtained, } } /// Exact expected recipient. - pub const fn recipient(self) -> PublicKey { - self.recipient + pub const fn target(self) -> SigningTarget { + self.target + } + pub fn recipient(self) -> Result<PublicKey, OperationError> { + self.target + .recipient() + .ok_or(OperationError::UnsupportedOperation) } /// Expected retained seal ID, when a complete plan exists. pub const fn expected_event(self) -> Option<EnvelopeEventId> { @@ -138,9 +148,9 @@ impl RecipientSnapshot { self.obtained } } -impl fmt::Debug for RecipientSnapshot { +impl fmt::Debug for ArtifactSnapshot { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str("RecipientSnapshot(<redacted>)") + f.write_str("ArtifactSnapshot(<redacted>)") } } @@ -178,7 +188,7 @@ impl fmt::Debug for RetainedOperation { /// only. It grants no authentication, backend qualification or installation fact. pub struct OperationSnapshot { retained: RetainedOperation, - recipients: Box<[RecipientSnapshot]>, + artifacts: Box<[ArtifactSnapshot]>, observed_at: UnixSeconds, installation: Option<ChatInstallation>, message: Option<ChatMessage>, @@ -226,8 +236,8 @@ impl OperationSnapshot { } None => digest.update([0]), } - for recipient in self.recipients() { - digest.update(recipient.recipient().as_bytes()); + for recipient in self.artifacts() { + digest.update(recipient.target().key()); match recipient.claim() { Some(claim) => { digest.update([1]); @@ -265,12 +275,12 @@ impl OperationSnapshot { None => digest.update([0]), } for work in self.publications() { - digest.update(work.evidence().recipient().as_bytes()); + digest.update(work.evidence().target().key()); digest.update(work.transaction_id().as_bytes()); digest.update(work.queued_at().get().to_be_bytes()); } for attempt in self.delivery_attempts() { - digest.update(attempt.work().evidence().recipient().as_bytes()); + digest.update(attempt.work().evidence().target().key()); digest.update(attempt.intent().digest()); digest.update(attempt.envelope_digest()); digest.update(attempt.transaction_id().as_bytes()); @@ -278,7 +288,7 @@ impl OperationSnapshot { digest.update(attempt.target_ordinals()); } for observation in self.delivery_observations() { - digest.update(observation.work().evidence().recipient().as_bytes()); + digest.update(observation.work().evidence().target().key()); digest.update(observation.request_id().as_str().as_bytes()); digest.update(observation.event_id().as_bytes()); digest.update(observation.envelope_digest()); @@ -328,28 +338,32 @@ impl OperationSnapshot { } radroots_domain::CheckpointDigest::from_bytes(digest.finalize().into()) } - /// Checks the exact complete recipient set, original claim scope and obtained + /// Checks the exact complete artifact set, original claim scope and obtained /// references. Concrete adapters must independently authenticate all rows and /// compare both retained and absent facts in one coherent transaction. pub fn from_store_report( retained: RetainedOperation, - recipients: Vec<RecipientSnapshot>, + artifacts: Vec<ArtifactSnapshot>, observed_at: UnixSeconds, ) -> Result<Self, OperationError> { - retained.prepared().request().chat_command()?; - if recipients.is_empty() || recipients.len() > 2 || observed_at.get() == 0 { + if artifacts.is_empty() || artifacts.len() > 2 || observed_at.get() == 0 { return Err(OperationError::RecoveryRequired); } let prepared = retained.prepared(); - let command = prepared.request().chat_command()?; - let mut expected = vec![command.context().actor().participant(), command.peer()]; - expected.sort_unstable(); + let mut expected = match prepared.request().command().chat() { + Some(command) => vec![ + SigningTarget::BusinessSeal(command.context().actor().participant()), + SigningTarget::BusinessSeal(command.peer()), + ], + None => vec![SigningTarget::PublicEvent], + }; + expected.sort_unstable_by_key(|target| target.key()); expected.dedup(); - if recipients.len() != expected.len() { + if artifacts.len() != expected.len() { return Err(OperationError::RecoveryRequired); } - for (recipient, expected) in recipients.iter().zip(expected) { - if recipient.recipient != expected { + for (recipient, expected) in artifacts.iter().zip(expected) { + if recipient.target != expected { return Err(OperationError::RecoveryRequired); } let Some(bound) = retained.bound_plan() else { @@ -361,13 +375,11 @@ impl OperationSnapshot { } continue; }; - let seal = bound - .chat_plan()? - .seals() - .iter() - .find(|seal| seal.recipient() == expected) - .ok_or(OperationError::RecoveryRequired)?; - let event = EnvelopeEventId::from_bytes(seal.event_id()); + let artifact = bound + .plan() + .artifact(expected) + .map_err(|_| OperationError::RecoveryRequired)?; + let event = EnvelopeEventId::from_bytes(artifact.event_id()); if recipient.expected_event != Some(event) { return Err(OperationError::RecoveryRequired); } @@ -377,7 +389,7 @@ impl OperationSnapshot { || claim.operation != identity.operation_id() || claim.command != identity.command_digest() || &claim.plan != bound.plan().digest() - || claim.recipient != expected + || claim.target != expected || claim.event != event || claim.intent.operation_id() != identity.operation_id() || claim.intent.command_digest() != identity.command_digest().as_bytes() @@ -391,7 +403,7 @@ impl OperationSnapshot { || obtained.operation_id() != claim.operation || obtained.command_digest() != claim.command || obtained.attempt_id() != claim.attempt - || obtained.recipient() != expected + || obtained.target() != expected || obtained.event_id() != event) { return Err(OperationError::RecoveryRequired); @@ -402,7 +414,7 @@ impl OperationSnapshot { } Ok(Self { retained, - recipients: recipients.into_boxed_slice(), + artifacts: artifacts.into_boxed_slice(), observed_at, installation: None, message: None, @@ -440,18 +452,18 @@ impl OperationSnapshot { )?; if checked != installed || !self - .recipients() + .artifacts() .iter() .any(|recipient| recipient.obtained() == Some(installed.basis())) || publications.is_empty() - || publications.len() > self.recipients().len() + || publications.len() > self.artifacts().len() { return Err(OperationError::RecoveryRequired); } let mut previous = None; let mut basis_linked = false; for work in &publications { - let recipient = work.evidence().recipient(); + let recipient = work.recipient(); if previous.is_some_and(|key| key >= recipient) || PublicationWork::from_committed_store( bound, @@ -461,7 +473,7 @@ impl OperationSnapshot { work.queued_at(), )? != *work || !self - .recipients() + .artifacts() .iter() .any(|value| value.obtained() == Some(work.evidence())) { @@ -522,11 +534,11 @@ impl OperationSnapshot { } attempts.sort_by(|a, b| { ( - a.work().evidence().recipient(), + a.work().evidence().target().recipient(), a.intent().request_id().as_str(), ) .cmp(&( - b.work().evidence().recipient(), + b.work().evidence().target().recipient(), b.intent().request_id().as_str(), )) }); @@ -536,7 +548,7 @@ impl OperationSnapshot { let mut slots = 0usize; let mut policies = BTreeMap::new(); for attempt in &attempts { - let recipient = attempt.work().evidence().recipient(); + let recipient = attempt.work().recipient(); slots = slots .checked_add(attempt.intent().selection().len()) .filter(|n| *n <= 384) @@ -576,13 +588,13 @@ impl OperationSnapshot { } observations.sort_by(|a, b| { ( - a.work().evidence().recipient(), + a.work().evidence().target().recipient(), a.request_id().as_str(), a.target_receipt().target().fingerprint().as_str(), a.kind().code(), ) .cmp(&( - b.work().evidence().recipient(), + b.work().evidence().target().recipient(), b.request_id().as_str(), b.target_receipt().target().fingerprint().as_str(), b.kind().code(), @@ -615,7 +627,7 @@ impl OperationSnapshot { .targets() .contains(observation.target_receipt().target()) || !seen.insert(( - observation.work().evidence().recipient(), + observation.work().recipient(), observation.request_id().as_str(), observation.target_receipt().target().fingerprint().as_str(), observation.kind().code(), @@ -681,8 +693,8 @@ impl OperationSnapshot { .map(|plan| plan.message_id()) } /// Complete sorted unique recipient set and independent outcomes. - pub fn recipients(&self) -> &[RecipientSnapshot] { - &self.recipients + pub fn artifacts(&self) -> &[ArtifactSnapshot] { + &self.artifacts } /// Actual query clock observation; never an issuance restart or global /// freshness guarantee. diff --git a/crates/storage_indexeddb/src/workspace/delivery/graph.rs b/crates/storage_indexeddb/src/workspace/delivery/graph.rs @@ -85,7 +85,7 @@ impl Graph { let work = installed .work .iter() - .find(|work| work.evidence().recipient() == participant) + .find(|work| work.recipient() == participant) .copied() .ok_or(OperationError::RecoveryRequired)?; let commitment = work_commitment( diff --git a/crates/storage_indexeddb/src/workspace/delivery/mod.rs b/crates/storage_indexeddb/src/workspace/delivery/mod.rs @@ -13,8 +13,8 @@ use radroots_secrets::context::{ EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId, }; use radroots_storage::command::{ - BoundSigningPlan, DeliveryAttempt, DeliveryIntent, OperationError, OperationSnapshot, - SealEvidence, SignedDmRelaySource, + ArtifactEvidence, BoundSigningPlan, DeliveryAttempt, DeliveryIntent, OperationError, + OperationSnapshot, SignedDmRelaySource, }; use sha2::{Digest, Sha256}; @@ -98,7 +98,7 @@ pub(super) struct Facts { pub snapshot: Option<OperationSnapshot>, pub selected: Option<DeliveryAttempt>, selected_slot: Option<Slot>, - pub original: Option<SealEvidence>, + pub original: Option<ArtifactEvidence>, pub slots: [u16; 2], } impl State { diff --git a/crates/storage_indexeddb/src/workspace/delivery/observation_operations.rs b/crates/storage_indexeddb/src/workspace/delivery/observation_operations.rs @@ -41,7 +41,7 @@ impl BrowserWorkspace { &t0, binding.observed_at(), Some(Selection { - recipient: evidence.recipient(), + recipient: evidence.recipient()?, request: supplied.request_id(), event: None, retain_seal: false, @@ -165,8 +165,7 @@ impl BrowserWorkspace { .delivery_observations() .iter() .filter(|value| { - value.work().evidence().recipient() == recipient - && value.request_id() == &request + value.work().recipient() == 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 @@ -7,9 +7,9 @@ use nostr::JsonUtil; use radroots_domain::{CommandDigest, OperationId, PublicKey, TransactionId}; use radroots_storage::{ command::{ - BoundSigningPlan, CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, + ArtifactEvidence, BoundSigningPlan, CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryAttemptSummary, EnvelopeCandidate, OperationError, - PublicationWork, SealEvidence, + PublicationWork, }, workspace::{AttachmentProof, WorkspaceBinding}, }; @@ -20,7 +20,7 @@ fn contains_original( candidate: &EnvelopeCandidate, work: PublicationWork, bound: &BoundSigningPlan, - source: &SealEvidence, + source: &ArtifactEvidence, ) -> Result<(), OperationError> { let actor = bound .prepared() @@ -32,7 +32,7 @@ fn contains_original( if candidate.work() != work || candidate.author() == actor || candidate.author() == bound.prepared().request().chat_command()?.peer() - || candidate.author() == work.evidence().recipient() + || candidate.author() == work.recipient() || source.digest() != work.evidence().digest() { return Err(OperationError::InvalidEvidence); @@ -44,7 +44,7 @@ fn contains_original( event .verify_with_ctx(&secp) .map_err(|_| OperationError::InvalidEvidence)?; - let recipient = nostr::PublicKey::from_slice(work.evidence().recipient().as_bytes()) + let recipient = nostr::PublicKey::from_slice(work.recipient().as_bytes()) .map_err(|_| OperationError::InvalidEvidence)?; let opened = candidate.with_wrapping_key(|key| { let secret = @@ -94,7 +94,7 @@ impl BrowserWorkspace { &t0, access.binding.observed_at(), Some(Selection { - recipient: evidence.recipient(), + recipient: evidence.recipient()?, request: request.intent().request_id(), event: Some(request.intent().event_id()), retain_seal: true, @@ -116,7 +116,7 @@ impl BrowserWorkspace { .chat_plan()? .seals() .iter() - .position(|seal| seal.recipient() == evidence.recipient()) + .position(|seal| Some(seal.recipient()) == evidence.target().recipient()) .ok_or(OperationError::InvalidEvidence)? as u8; let retained = facts .selected @@ -133,7 +133,7 @@ impl BrowserWorkspace { } let fresh = retained.is_none(); let (report, extra) = if fresh { - routes(bound, evidence.recipient(), request.intent())?; + routes(bound, evidence.recipient()?, request.intent())?; if snapshot.delivery_attempts().iter().any(|value| { value.work() == actual && value.intent().publication_policy_digest() diff --git a/crates/storage_indexeddb/src/workspace/installation.rs b/crates/storage_indexeddb/src/workspace/installation.rs @@ -172,14 +172,14 @@ impl BrowserWorkspace { } let original = snapshot.installation(); let missing = snapshot - .recipients() + .artifacts() .iter() .filter_map(|value| value.obtained()) .filter(|evidence| { !snapshot .publications() .iter() - .any(|value| value.evidence().recipient() == evidence.recipient()) + .any(|value| value.evidence().target() == evidence.target()) }) .collect::<Vec<_>>(); if original.is_none() && missing.is_empty() { @@ -227,7 +227,7 @@ impl BrowserWorkspace { .chat_plan()? .seals() .iter() - .position(|seal| seal.recipient() == evidence.recipient()) + .position(|seal| Some(seal.recipient()) == evidence.target().recipient()) .ok_or(OperationError::RecoveryRequired)? as u8; let value = PublicationWork::from_committed_store( bound, diff --git a/crates/storage_indexeddb/src/workspace/installation/codec.rs b/crates/storage_indexeddb/src/workspace/installation/codec.rs @@ -19,6 +19,7 @@ fn encode( fields: [&[u8; 32]; 6], time: UnixSeconds, receipt: EvidenceReceipt, + recipient: PublicKey, ) -> Zeroizing<Vec<u8>> { let mut raw = Zeroizing::new(Vec::with_capacity(LENGTH)); raw.extend_from_slice(magic); @@ -30,7 +31,7 @@ fn encode( receipt.workspace_id().as_bytes(), receipt.operation_id().as_bytes(), receipt.command_digest().as_bytes(), - receipt.recipient().as_bytes(), + recipient.as_bytes(), receipt.attempt_id().as_bytes(), receipt.event_id().as_bytes(), receipt.digest(), @@ -93,6 +94,7 @@ pub(super) fn message( ], value.installed_at(), value.basis(), + value.basis().recipient()?, )) } pub(super) fn decode_message( @@ -125,6 +127,7 @@ pub(super) fn work(installed: ChatInstallation, value: PublicationWork) -> Zeroi ], value.queued_at(), value.evidence(), + value.recipient(), ) } pub(super) fn decode_work( diff --git a/crates/storage_indexeddb/src/workspace/issuance.rs b/crates/storage_indexeddb/src/workspace/issuance.rs @@ -8,8 +8,9 @@ use radroots_secrets::context::{ }; use radroots_storage::{ command::{ - BoundSigningPlan, CapturedSeal, ClaimAttemptOutcome, ClaimAttemptRequest, CommitAttempt, - EvidenceCaptureOutcome, EvidenceReceipt, OperationError, SealEvidence, SigningAttempt, + ArtifactEvidence, BoundSigningPlan, CapturedArtifact, ClaimAttemptOutcome, + ClaimAttemptRequest, CommitAttempt, EvidenceCaptureOutcome, EvidenceReceipt, + OperationError, SigningAttempt, protected::{ self, issuance::{ClaimRecord, EvidenceManifest}, @@ -130,7 +131,7 @@ impl State { view: &ReadSnapshot, attempt: &SigningAttempt, index: u8, - ) -> Result<Option<(SealEvidence, EvidenceReceipt)>, OperationError> { + ) -> Result<Option<(ArtifactEvidence, EvidenceReceipt)>, OperationError> { let operation = attempt.bound_plan().prepared().identity().operation_id(); let mut records = Vec::with_capacity(5); for part in 0..=4 { @@ -198,7 +199,7 @@ impl State { &self, attempt: &SigningAttempt, index: u8, - supplied: &SealEvidence, + supplied: &ArtifactEvidence, transaction: TransactionId, ) -> Result<Vec<Mutation>, OperationError> { let manifest = EvidenceManifest::capture(attempt, supplied, transaction)?; @@ -270,9 +271,9 @@ impl BrowserWorkspace { return Err(OperationError::IdempotencyConflict); } let index = - position(&bound, request.recipient())?.ok_or(OperationError::InvalidCommand)?; + position(&bound, request.recipient()?)?.ok_or(OperationError::InvalidCommand)?; let (attempt, fresh, extra) = match state - .claim(&view, bound, request.recipient(), index) + .claim(&view, bound, request.recipient()?, index) .await? { Claim::Present(attempt) => (attempt, false, Vec::new()), @@ -295,7 +296,7 @@ impl BrowserWorkspace { } let attempt = SigningAttempt::from_committed_store( bound, - request.recipient(), + request.recipient()?, SigningAttemptId::from_bytes(*crypto::random::<32>()?), TransactionId::from_bytes(*crypto::random::<32>()?), now, @@ -370,9 +371,9 @@ impl BrowserWorkspace { if bound.plan().digest() != request.plan_digest() { return Err(OperationError::IdempotencyConflict); } - if let Some(index) = position(&bound, request.recipient())? { + if let Some(index) = position(&bound, request.recipient()?)? { match state - .claim(&view, bound, request.recipient(), index) + .claim(&view, bound, request.recipient()?, index) .await? { Claim::Present(attempt) => Some(attempt), @@ -410,9 +411,9 @@ impl BrowserWorkspace { &self, input: AttachmentInput, proof: &AttachmentProof, - supplied: &SealEvidence, + supplied: &ArtifactEvidence, ) -> Result<EvidenceCaptureOutcome, OperationError> { - let capture_identity = super::recovery::CaptureIdentity::seal(supplied); + let capture_identity = super::recovery::CaptureIdentity::artifact(supplied); let owned_identity = capture_identity.clone(); let fallback = CommitAttempt::new( supplied.workspace_id(), @@ -437,9 +438,9 @@ impl BrowserWorkspace { .await? .ok_or(OperationError::RecoveryRequired)?; let index = - position(&bound, supplied.recipient())?.ok_or(OperationError::InvalidEvidence)?; + position(&bound, supplied.recipient()?)?.ok_or(OperationError::InvalidEvidence)?; let attempt = match state - .claim(&view, bound, supplied.recipient(), index) + .claim(&view, bound, supplied.recipient()?, index) .await? { Claim::Present(attempt) => attempt, @@ -448,7 +449,7 @@ impl BrowserWorkspace { if !supplied.matches_attempt(&attempt) { return Err(OperationError::InvalidEvidence); } - let checked = SealEvidence::verify( + let checked = ArtifactEvidence::verify( &attempt, supplied.raw_json(), supplied.observed_at_unix_ms(), @@ -517,7 +518,7 @@ impl BrowserWorkspace { &self, request: ClaimAttemptRequest, proof: AttachmentProof, - ) -> Result<Option<CapturedSeal>, OperationError> { + ) -> Result<Option<CapturedArtifact>, OperationError> { let work = self.state.admit()?; let state = self.state.clone(); owned(work, async move { @@ -533,9 +534,9 @@ impl BrowserWorkspace { if bound.plan().digest() != request.plan_digest() { return Err(OperationError::IdempotencyConflict); } - if let Some(index) = position(&bound, request.recipient())? { + if let Some(index) = position(&bound, request.recipient()?)? { match state - .claim(&view, bound, request.recipient(), index) + .claim(&view, bound, request.recipient()?, index) .await? { Claim::Present(attempt) => { @@ -553,7 +554,7 @@ impl BrowserWorkspace { } obtained .map(|(evidence, receipt)| { - CapturedSeal::from_committed_store( + CapturedArtifact::from_committed_store( attempt, evidence, receipt.transaction_id(), diff --git a/crates/storage_indexeddb/src/workspace/ports.rs b/crates/storage_indexeddb/src/workspace/ports.rs @@ -3,12 +3,12 @@ use super::BrowserWorkspace; use radroots_domain::{CommandDigest, OperationId, PublicKey}; use radroots_storage::{ command::{ - AdmissionOutcome, AdmissionRequest, BoundSigningPlan, CapturedSeal, CapturedSigningPlan, - ClaimAttemptOutcome, ClaimAttemptRequest, DeliveryAttempt, DeliveryAttemptOutcome, - DeliveryAttemptRequest, DeliveryObservation, DeliveryObservationOutcome, EnvelopeCandidate, - EvidenceCaptureOutcome, InstallationOutcome, InstallationRequest, OperationError, - OperationJournal, OperationSnapshot, PlanBindingOutcome, PreparedOperation, SealEvidence, - SigningAttempt, + AdmissionOutcome, AdmissionRequest, ArtifactEvidence, BoundSigningPlan, CapturedArtifact, + CapturedSigningPlan, ClaimAttemptOutcome, ClaimAttemptRequest, DeliveryAttempt, + DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryObservation, + DeliveryObservationOutcome, EnvelopeCandidate, EvidenceCaptureOutcome, InstallationOutcome, + InstallationRequest, OperationError, OperationJournal, OperationSnapshot, + PlanBindingOutcome, PreparedOperation, SigningAttempt, }, workspace::{AttachmentInput, AttachmentProof, WorkspaceBinding}, }; @@ -19,7 +19,7 @@ impl OperationJournal for BrowserWorkspace { &'a self, input: AttachmentInput, proof: &'a AttachmentProof, - evidence: &'a SealEvidence, + evidence: &'a ArtifactEvidence, ) -> BoxFuture<'a, Result<EvidenceCaptureOutcome, OperationError>> { Box::pin(BrowserWorkspace::capture_evidence( self, input, proof, evidence, @@ -112,7 +112,7 @@ impl OperationJournal for BrowserWorkspace { &'a self, input: AttachmentInput, proof: &'a AttachmentProof, - evidence: &'a SealEvidence, + evidence: &'a ArtifactEvidence, ) -> BoxFuture<'a, Result<EvidenceCaptureOutcome, OperationError>> { Box::pin(BrowserWorkspace::capture_evidence( self, input, proof, evidence, @@ -122,7 +122,7 @@ impl OperationJournal for BrowserWorkspace { &self, request: ClaimAttemptRequest, proof: AttachmentProof, - ) -> BoxFuture<'_, Result<Option<CapturedSeal>, OperationError>> { + ) -> BoxFuture<'_, Result<Option<CapturedArtifact>, OperationError>> { Box::pin(BrowserWorkspace::obtained_evidence(self, request, proof)) } fn bind_signing_intents( 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::{ - DeliveryObservation, DeliveryObservationKind, PublicationWork, SealEvidence, + ArtifactEvidence, DeliveryObservation, DeliveryObservationKind, PublicationWork, }; use radroots_storage::workspace::{ AttachmentInput, AttachmentProof, local_outbox::LocalOutboxGrant, @@ -23,7 +23,7 @@ pub(super) enum CaptureIdentity { }, } impl CaptureIdentity { - pub fn seal(value: &SealEvidence) -> Self { + pub fn artifact(value: &ArtifactEvidence) -> Self { Self::Seal { operation: value.operation_id(), digest: *value.digest(), diff --git a/crates/storage_indexeddb/src/workspace/retained.rs b/crates/storage_indexeddb/src/workspace/retained.rs @@ -3,8 +3,8 @@ use super::{State, address, issuance::Claim, journal::Records}; use crate::ReadSnapshot; use radroots_domain::{CommandDigest, EnvelopeEventId, OperationId, PublicKey, UnixSeconds}; use radroots_storage::command::{ - BoundSigningPlan, ClaimSnapshot, EvidenceReceipt, OperationError, OperationSnapshot, - RecipientSnapshot, RetainedOperation, SealEvidence, protected, + ArtifactEvidence, ArtifactSnapshot, BoundSigningPlan, ClaimSnapshot, EvidenceReceipt, + OperationError, OperationSnapshot, RetainedOperation, protected, }; pub(super) async fn header( @@ -52,8 +52,8 @@ pub(super) async fn header( pub(super) struct Graph { retained: Option<RetainedOperation>, - recipients: Vec<RecipientSnapshot>, - output: Option<SealEvidence>, + recipients: Vec<ArtifactSnapshot>, + output: Option<ArtifactEvidence>, } impl Graph { pub(super) async fn read_for_output( @@ -81,7 +81,7 @@ impl Graph { EnvelopeEventId::from_bytes(bound.chat_plan()?.seals()[index].event_id()); match state.claim(view, bound, recipient, index as u8).await? { Claim::Absent(returned, _) => { - recipients.push(RecipientSnapshot::from_store_report( + recipients.push(ArtifactSnapshot::from_store_report( recipient, Some(expected), None, @@ -98,7 +98,7 @@ impl Graph { if Some(recipient) == selected { output = obtained.map(|(value, _)| value); } - recipients.push(RecipientSnapshot::from_store_report( + recipients.push(ArtifactSnapshot::from_store_report( recipient, Some(expected), Some(claim), @@ -116,7 +116,7 @@ impl Graph { keys.sort_unstable(); keys.dedup(); for recipient in keys { - recipients.push(RecipientSnapshot::from_store_report( + recipients.push(ArtifactSnapshot::from_store_report( recipient, None, None, None, )); } @@ -130,7 +130,7 @@ impl Graph { output, }) } - pub(super) fn take_output(&mut self) -> Option<SealEvidence> { + pub(super) fn take_output(&mut self) -> Option<ArtifactEvidence> { self.output.take() } pub(super) fn bound(&self) -> Option<&BoundSigningPlan> { @@ -141,7 +141,7 @@ impl Graph { pub(super) fn receipt(&self, recipient: PublicKey) -> Result<EvidenceReceipt, OperationError> { self.recipients .iter() - .find(|value| value.recipient() == recipient) + .find(|value| value.target().recipient() == Some(recipient)) .and_then(|value| value.obtained()) .ok_or(OperationError::RecoveryRequired) } diff --git a/crates/storage_indexeddb/tests/browser/seller.mjs b/crates/storage_indexeddb/tests/browser/seller.mjs @@ -23,6 +23,9 @@ async function workflow({WorkspaceFixture}, previous) { const original = Array.from(await old.admit(243, false)); const originalPlanWire = Uint8Array.from(await old.new_plan(243)); const originalPlan = Array.from(await old.bind_plan(243, originalPlanWire)); + const obtained = await old.obtain(243, 0, false); + const originalClaim = Array.from(obtained.original_claim()); + const originalCapture = Array.from(await old.capture(obtained)); await old.close(); const current = await WorkspaceFixture.open(244, oldFingerprint, oldSelection, oldProof); check(!await current.is_seller()); @@ -30,8 +33,11 @@ async function workflow({WorkspaceFixture}, previous) { check(JSON.stringify(Array.from(await current.admit(243, false))) === JSON.stringify(original)); check(JSON.stringify(Array.from(await current.plan_query(243))) === JSON.stringify(originalPlan)); check(JSON.stringify(Array.from(await current.bind_plan(243, originalPlanWire))) === JSON.stringify(originalPlan)); + check(JSON.stringify(Array.from(await current.attempt(243, 0))) === JSON.stringify(originalClaim)); + check(JSON.stringify(Array.from(await current.captured(243, 0))) === JSON.stringify(originalCapture)); + await refuses(() => current.obtain(243, 0, false), 'retained_no_dispatch'); await current.close(); - tests.push('original published buyer preparation and signing plan reopen and replay without replacement'); + tests.push('original published buyer T0, T1, claim and obtained capture reopen without replacement or reissue'); const seller = await WorkspaceFixture.create_seller(245); check(await seller.is_seller()); check(await seller.authenticate() === 1); diff --git a/crates/storage_indexeddb/tests/browser/src/workspace/delivery.rs b/crates/storage_indexeddb/tests/browser/src/workspace/delivery.rs @@ -157,7 +157,7 @@ impl WorkspaceFixture { let work = snapshot .publications() .iter() - .find(|work| work.evidence().recipient() == recipient) + .find(|work| work.recipient() == recipient) .copied() .ok_or(JsValue::from_str("missing_work"))?; let retained = self diff --git a/crates/storage_indexeddb/tests/browser/src/workspace/installation.rs b/crates/storage_indexeddb/tests/browser/src/workspace/installation.rs @@ -8,7 +8,7 @@ use serde_json::{Value, json}; use wasm_bindgen::prelude::*; fn installation(value: ChatInstallation) -> Value { - json!({"transaction":value.transaction_id().to_string(),"message":value.message_id().to_string(),"at":value.installed_at().get(),"basis_capture":value.basis().transaction_id().to_string(),"basis_recipient":value.basis().recipient().to_string()}) + json!({"transaction":value.transaction_id().to_string(),"message":value.message_id().to_string(),"at":value.installed_at().get(),"basis_capture":value.basis().transaction_id().to_string(),"basis_recipient":value.basis().recipient().unwrap().to_string()}) } fn snapshot(value: &OperationSnapshot) -> Value { json!({ @@ -16,8 +16,8 @@ fn snapshot(value: &OperationSnapshot) -> Value { "preparation":value.prepared().transaction_id().to_string(), "plan":value.bound_plan().map(|bound|bound.transaction_id().to_string()), "installation":value.installation().map(installation), - "publications":value.publications().iter().map(|work|json!({"recipient":work.evidence().recipient().to_string(),"transaction":work.transaction_id().to_string(),"capture":work.evidence().transaction_id().to_string(),"installation":work.installation_transaction_id().to_string(),"at":work.queued_at().get()})).collect::<Vec<_>>(), - "claims":value.recipients().iter().map(|recipient|json!({"recipient":recipient.recipient().to_string(),"claim":recipient.claim().map(|claim|claim.attempt_id().to_string()),"capture":recipient.obtained().map(|capture|capture.transaction_id().to_string())})).collect::<Vec<_>>(), + "publications":value.publications().iter().map(|work|json!({"recipient":work.recipient().to_string(),"transaction":work.transaction_id().to_string(),"capture":work.evidence().transaction_id().to_string(),"installation":work.installation_transaction_id().to_string(),"at":work.queued_at().get()})).collect::<Vec<_>>(), + "claims":value.artifacts().iter().map(|recipient|json!({"recipient":recipient.recipient().unwrap().to_string(),"claim":recipient.claim().map(|claim|claim.attempt_id().to_string()),"capture":recipient.obtained().map(|capture|capture.transaction_id().to_string())})).collect::<Vec<_>>(), "message":value.installed_message().map(|message|json!({"id":message.id().to_string(),"peer":message.peer().to_string(),"text":message.text(),"created_at":message.created_at().get()})), "deliveries":value.delivery_attempts().len(),"observations":value.delivery_observations().len(), }) diff --git a/crates/storage_indexeddb/tests/browser/src/workspace/issuance.rs b/crates/storage_indexeddb/tests/browser/src/workspace/issuance.rs @@ -4,8 +4,8 @@ use core::num::NonZeroU64; use futures::FutureExt; use nostr::JsonUtil; use radroots_storage::command::{ - ClaimAttemptOutcome, ClaimAttemptRequest, EvidenceCaptureOutcome, EvidenceReceipt, - SealEvidence, SigningAttempt, + ArtifactEvidence, ClaimAttemptOutcome, ClaimAttemptRequest, EvidenceCaptureOutcome, + EvidenceReceipt, SigningAttempt, }; use wasm_bindgen::prelude::*; @@ -34,7 +34,7 @@ fn receipt(value: EvidenceReceipt) -> Vec<u8> { fn signed_output( attempt: &SigningAttempt, observed: Option<NonZeroU64>, -) -> Result<SealEvidence, JsValue> { +) -> Result<ArtifactEvidence, JsValue> { let fields = attempt.seal().unwrap().fields(); let context = nostr::secp256k1::Secp256k1::new(); let mut scalar = [0; 32]; @@ -52,13 +52,13 @@ fn signed_output( .sign_with_ctx(&context, &mut BrowserRng, &keys) .unwrap(); signed.verify_with_ctx(&context).unwrap(); - SealEvidence::verify(attempt, &signed.as_json(), observed) + ArtifactEvidence::verify(attempt, &signed.as_json(), observed) .map_err(|e| JsValue::from_str(e.code())) } /// The test caller keeps its opaque original through failed/unknown capture. #[wasm_bindgen] pub struct ObtainedSeal { - value: SealEvidence, + value: ArtifactEvidence, attempt: SigningAttempt, } #[wasm_bindgen] @@ -82,8 +82,12 @@ impl ObtainedSeal { "kind" => serde_json::json!(14), _ => unreachable!(), }; - SealEvidence::verify(&self.attempt, &serde_json::to_string(&wrong).unwrap(), None) - .is_err() + ArtifactEvidence::verify( + &self.attempt, + &serde_json::to_string(&wrong).unwrap(), + None, + ) + .is_err() }) } } @@ -234,7 +238,7 @@ impl WorkspaceFixture { .map_err(|e| JsValue::from_str(e.code())) } pub async fn capture_reobserved(&self, original: &ObtainedSeal) -> Result<Vec<u8>, JsValue> { - let evidence = SealEvidence::verify( + let evidence = ArtifactEvidence::verify( &original.attempt, original.value.raw_json(), NonZeroU64::new(1_000_100), 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().evidence().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().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 { @@ -179,7 +179,7 @@ impl WorkspaceFixture { original.binding.clone(), evidence.operation_id(), evidence.command_digest(), - evidence.recipient(), + evidence.recipient().unwrap(), original.value.request_id().clone(), copied(&self.proof), ) diff --git a/crates/storage_sqlite/Cargo.toml b/crates/storage_sqlite/Cargo.toml @@ -62,7 +62,7 @@ zeroize = { workspace = true, features = ["alloc"] } sqlx = { workspace = true, features = ["runtime-tokio", "sqlite-bundled"] } [dev-dependencies] -radroots_signing = { workspace = true, features = ["chat"] } +radroots_signing = { workspace = true, features = ["chat", "artifacts"] } radroots_nostr = { workspace = true, default-features = false, features = ["signing", "nip17"] } radroots_protocol = { workspace = true, default-features = false, features = ["chat"] } nostr = { workspace = true, default-features = false, features = ["std", "nip44"] } diff --git a/crates/storage_sqlite/src/workspace/admission.rs b/crates/storage_sqlite/src/workspace/admission.rs @@ -239,7 +239,7 @@ impl Journal<'_> { .fetch_one(&mut *self.connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - if version != 8 { + if !matches!(version, 8 | 9) { return Err(OperationError::UnsupportedOperation); } } diff --git a/crates/storage_sqlite/src/workspace/attempt.rs b/crates/storage_sqlite/src/workspace/attempt.rs @@ -3,12 +3,14 @@ use super::{ AttachmentInput, crypto::{IssuancePayload, IssuanceScope, WorkspaceCrypto}, }; -use radroots_domain::{PublicKey, SigningAttemptId, TransactionId, UnixSeconds}; +use radroots_domain::{SigningAttemptId, TransactionId, UnixSeconds}; +use radroots_storage::command::SigningTarget; use radroots_storage::command::protected::issuance::ClaimRecord; use radroots_storage::command::{BoundSigningPlan, ClaimSnapshot, OperationError, SigningAttempt}; use sqlx::{Row, SqliteConnection}; -pub(super) const TABLE: &str = "CREATE TABLE signing_attempts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), plan_digest BLOB NOT NULL CHECK(length(plan_digest)=32), intent_digest BLOB NOT NULL CHECK(length(intent_digest)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id) REFERENCES signing_plans(workspace,operation_id)) STRICT, WITHOUT ROWID"; +pub(super) const TABLE: &str = "CREATE TABLE signing_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')), attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), plan_digest BLOB NOT NULL CHECK(length(plan_digest)=32), intent_digest BLOB NOT NULL CHECK(length(intent_digest)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key), FOREIGN KEY(workspace,operation_id) REFERENCES signing_plans(workspace,operation_id)) STRICT, WITHOUT ROWID"; +pub(super) const TABLE_V8: &str = "CREATE TABLE signing_attempts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), plan_digest BLOB NOT NULL CHECK(length(plan_digest)=32), intent_digest BLOB NOT NULL CHECK(length(intent_digest)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id) REFERENCES signing_plans(workspace,operation_id)) STRICT, WITHOUT ROWID"; pub(super) const ID_INDEX: &str = "CREATE UNIQUE INDEX signing_attempt_identity ON signing_attempts(workspace,attempt_id)"; pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX signing_attempt_transaction_identity ON signing_attempts(workspace,transaction_id)"; @@ -20,7 +22,7 @@ pub(super) fn scope(attempt: &SigningAttempt) -> Result<IssuanceScope, Operation operation: identity.operation_id(), plan_digest: *attempt.bound_plan().plan().digest(), attempt: attempt.attempt_id(), - recipient: attempt.seal()?.recipient(), + target: attempt.target(), }) } pub(super) async fn protect( @@ -38,7 +40,7 @@ pub(super) async fn read( connection: &mut SqliteConnection, selected: &AttachmentInput, bound: BoundSigningPlan, - recipient: PublicKey, + target: impl Into<SigningTarget>, crypto: &WorkspaceCrypto, ) -> Result< ( @@ -47,9 +49,10 @@ pub(super) async fn read( ), OperationError, > { + let target = target.into(); let original = bound.prepared().identity(); - let row=sqlx::query("SELECT CASE WHEN length(attempt_id)=32 THEN attempt_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,CASE WHEN length(plan_digest)=32 THEN plan_digest END,CASE WHEN length(intent_digest)=32 THEN intent_digest END,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM signing_attempts WHERE workspace=? AND operation_id=? AND recipient=?") - .bind(selected.workspace_id().as_bytes().as_slice()).bind(original.operation_id().as_bytes().as_slice()).bind(recipient.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let row=sqlx::query(sql(connection, "SELECT CASE WHEN length(attempt_id)=32 THEN attempt_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,CASE WHEN length(plan_digest)=32 THEN plan_digest END,CASE WHEN length(intent_digest)=32 THEN intent_digest END,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM signing_attempts WHERE workspace=? AND operation_id=? AND recipient=?").await?) + .bind(selected.workspace_id().as_bytes().as_slice()).bind(original.operation_id().as_bytes().as_slice()).bind(target.key().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; let Some(row) = row else { return Ok((bound, None)); }; @@ -79,12 +82,12 @@ pub(super) async fn read( operation: original.operation_id(), plan_digest: *bound.plan().digest(), attempt: id, - recipient, + target, }; let plaintext = crypto .open_issuance(issuance_scope, IssuancePayload::Attempt, 0, &protected) .await?; - let attempt = plaintext.expose_secret(|raw| ClaimRecord::decode(raw, bound, recipient))?; + let attempt = plaintext.expose_secret(|raw| ClaimRecord::decode(raw, bound, target))?; if attempt.attempt_id() != id || attempt.transaction_id() != transaction || intent_digest.as_slice() != attempt.binding().digest() @@ -103,9 +106,10 @@ pub(super) async fn insert( attempt: &SigningAttempt, protected: &[u8], ) -> Result<(), OperationError> { + require_target(connection, attempt.target()).await?; let identity = attempt.bound_plan().prepared().identity(); - sqlx::query("INSERT INTO signing_attempts(workspace,operation_id,recipient,attempt_id,transaction_id,plan_digest,intent_digest,protected) VALUES(?,?,?,?,?,?,?,?)") - .bind(identity.workspace_id().as_bytes().as_slice()).bind(identity.operation_id().as_bytes().as_slice()).bind(attempt.seal()?.recipient().as_bytes().as_slice()).bind(attempt.attempt_id().as_bytes().as_slice()).bind(attempt.transaction_id().as_bytes().as_slice()).bind(attempt.bound_plan().plan().digest().as_slice()).bind(attempt.binding().digest().as_slice()).bind(protected).execute(connection).await.map_err(|_|OperationError::StorageFailure)?; + sqlx::query(sql(connection, "INSERT INTO signing_attempts(workspace,operation_id,recipient,attempt_id,transaction_id,plan_digest,intent_digest,protected) VALUES(?,?,?,?,?,?,?,?)").await?) + .bind(identity.workspace_id().as_bytes().as_slice()).bind(identity.operation_id().as_bytes().as_slice()).bind(attempt.target().key().as_slice()).bind(attempt.attempt_id().as_bytes().as_slice()).bind(attempt.transaction_id().as_bytes().as_slice()).bind(attempt.bound_plan().plan().digest().as_slice()).bind(attempt.binding().digest().as_slice()).bind(protected).execute(connection).await.map_err(|_|OperationError::StorageFailure)?; Ok(()) } pub(super) async fn unchanged( @@ -125,10 +129,47 @@ pub(super) async fn unchanged_snapshot( snapshot: ClaimSnapshot, protected: &[u8], ) -> Result<(), OperationError> { - let count:i64=sqlx::query_scalar("SELECT count(*) FROM signing_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND attempt_id=? AND transaction_id=? AND plan_digest=? AND intent_digest=? AND protected=?") - .bind(snapshot.workspace_id().as_bytes().as_slice()).bind(snapshot.operation_id().as_bytes().as_slice()).bind(snapshot.recipient().as_bytes().as_slice()).bind(snapshot.attempt_id().as_bytes().as_slice()).bind(snapshot.transaction_id().as_bytes().as_slice()).bind(snapshot.plan_digest().as_slice()).bind(snapshot.intent().digest().as_slice()).bind(protected).fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let count:i64=sqlx::query_scalar(sql(connection, "SELECT count(*) FROM signing_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND attempt_id=? AND transaction_id=? AND plan_digest=? AND intent_digest=? AND protected=?").await?) + .bind(snapshot.workspace_id().as_bytes().as_slice()).bind(snapshot.operation_id().as_bytes().as_slice()).bind(snapshot.target().key().as_slice()).bind(snapshot.attempt_id().as_bytes().as_slice()).bind(snapshot.transaction_id().as_bytes().as_slice()).bind(snapshot.plan_digest().as_slice()).bind(snapshot.intent().digest().as_slice()).bind(protected).fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; if count != 1 { return Err(OperationError::RecoveryRequired); } Ok(()) } + +/// Exact old catalogs retain their names and private bytes without migration. +/// This is identifier adaptation on the same transaction engine, not a fallback +/// schema or a second persistence implementation. +pub(super) async fn sql( + connection: &mut SqliteConnection, + legacy: &'static str, +) -> Result<sqlx::AssertSqlSafe<String>, OperationError> { + let version: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + match version { + 7 | 8 => Ok(sqlx::AssertSqlSafe(legacy.to_owned())), + 9 => Ok(sqlx::AssertSqlSafe( + legacy + .replace("seal_evidence", "artifact_evidence") + .replace("recipient", "artifact_key"), + )), + _ => Err(OperationError::RecoveryRequired), + } +} +pub(super) async fn require_target( + connection: &mut SqliteConnection, + target: SigningTarget, +) -> Result<(), OperationError> { + if target == SigningTarget::PublicEvent { + let version: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if version != 9 { + return Err(OperationError::UnsupportedOperation); + } + } + Ok(()) +} diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs @@ -21,7 +21,7 @@ pub(super) struct IssuanceScope { pub operation: OperationId, pub plan_digest: [u8; 32], pub attempt: radroots_domain::SigningAttemptId, - pub recipient: radroots_domain::PublicKey, + pub target: radroots_storage::command::SigningTarget, } #[derive(Clone, Copy)] pub(super) enum IssuancePayload { @@ -399,7 +399,7 @@ fn issuance_context( part: u8, ) -> Result<EnvelopeContext, WorkspaceError> { use sha2::{Digest, Sha256}; - let (tag, purpose, schema) = match payload { + let (tag, mut purpose, mut schema) = match payload { IssuancePayload::Attempt => ( 0u8, "radroots.workspace.signing_attempt", @@ -423,7 +423,25 @@ fn issuance_context( hash.update(scope.operation.as_bytes()); hash.update(scope.plan_digest); hash.update(scope.attempt.as_bytes()); - hash.update(scope.recipient.as_bytes()); + match scope.target { + radroots_storage::command::SigningTarget::BusinessSeal(recipient) => { + hash.update(recipient.as_bytes()) + } + radroots_storage::command::SigningTarget::PublicEvent => { + if matches!(payload, IssuancePayload::Publication) { + return Err(WorkspaceError::InvalidInput); + } + purpose = match payload { + IssuancePayload::Attempt => "radroots.workspace.public_signing_attempt", + _ => "radroots.workspace.public_artifact_evidence", + }; + schema = match payload { + IssuancePayload::Attempt => "radroots.workspace.public_signing_attempt.v1", + _ => "radroots.workspace.public_artifact_evidence.v1", + }; + hash.update(b"public_event.no_recipient.v1\0"); + } + } let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into()); Ok(EnvelopeContext::new( EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?, diff --git a/crates/storage_sqlite/src/workspace/delivery/codec.rs b/crates/storage_sqlite/src/workspace/delivery/codec.rs @@ -29,7 +29,7 @@ impl WorkRef { Self { installation: work.installation_transaction_id(), plan: *work.plan_digest(), - evidence: EvidenceRef::new(work.evidence()), + evidence: EvidenceRef::new(work.evidence(), work.recipient()), transaction: work.transaction_id(), queued_at: work.queued_at(), } @@ -148,7 +148,7 @@ pub(super) fn scope(work: PublicationWork, key: [u8; 32]) -> DeliveryScope { DeliveryScope { workspace: e.workspace_id(), operation: e.operation_id(), - recipient: e.recipient(), + recipient: work.recipient(), request: key, } } diff --git a/crates/storage_sqlite/src/workspace/delivery/graph.rs b/crates/storage_sqlite/src/workspace/delivery/graph.rs @@ -99,7 +99,7 @@ impl Graph { let work = installed .work .iter() - .find(|work| work.report.evidence().recipient() == recipient) + .find(|work| work.report.recipient() == recipient) .ok_or(OperationError::RecoveryRequired)? .report; let value = codec::read(connection, work, key, crypto) diff --git a/crates/storage_sqlite/src/workspace/delivery/graph_tests.rs b/crates/storage_sqlite/src/workspace/delivery/graph_tests.rs @@ -71,7 +71,7 @@ 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().evidence().recipient(); + let recipient = data.report.work().recipient(); let selected = [String::from("wss://route.example/")]; assert!( allowed_routes(&data.bound().await, recipient) @@ -160,7 +160,7 @@ 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().evidence().recipient(); + let recipient = data.report.work().recipient(); let mut graph = Graph { attempts: vec![], facts: vec![], @@ -342,7 +342,7 @@ mod cases { 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().as_bytes().as_slice()).bind(request.as_slice()).bind(target.as_slice()).execute(&mut data.database).await.unwrap(); + 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(); } let error = observation::Observations::read( &mut data.database, diff --git a/crates/storage_sqlite/src/workspace/delivery/observation.rs b/crates/storage_sqlite/src/workspace/delivery/observation.rs @@ -157,7 +157,7 @@ impl Observations { .attempts .iter() .find(|attempt| { - attempt.work().evidence().recipient().as_bytes() == &recipient + attempt.work().recipient().as_bytes() == &recipient && codec::request_key(attempt.intent().request_id().as_str()) == request }) .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 @@ -229,9 +229,7 @@ impl Journal<'_> { Ok(observations .reports .into_iter() - .filter(|value| { - value.request_id() == &request && value.work().evidence().recipient() == recipient - }) + .filter(|value| value.request_id() == &request && value.work().recipient() == recipient) .collect()) } } diff --git a/crates/storage_sqlite/src/workspace/delivery/operations.rs b/crates/storage_sqlite/src/workspace/delivery/operations.rs @@ -26,7 +26,7 @@ fn contains_original( .bound_plan() .ok_or(OperationError::RecoveryRequired)?; let source = original - .obtained(work.evidence().recipient()) + .obtained(work.recipient()) .ok_or(OperationError::RecoveryRequired)?; let actor = bound .prepared() @@ -38,7 +38,7 @@ fn contains_original( if candidate.work() != work || candidate.author() == actor || candidate.author() == bound.prepared().request().chat_command()?.peer() - || candidate.author() == work.evidence().recipient() + || candidate.author() == work.recipient() || source.digest() != work.evidence().digest() { return Err(OperationError::InvalidEvidence); @@ -48,7 +48,7 @@ fn contains_original( event .verify() .map_err(|_| OperationError::InvalidEvidence)?; - let recipient = nostr::PublicKey::from_slice(work.evidence().recipient().as_bytes()) + let recipient = nostr::PublicKey::from_slice(work.recipient().as_bytes()) .map_err(|_| OperationError::InvalidEvidence)?; let opened = candidate.with_wrapping_key(|key| { let secret = @@ -73,7 +73,7 @@ fn work(records: &Records, requested: PublicationWork) -> Result<PublicationWork let actual = records .work .iter() - .find(|value| value.report.evidence().recipient() == requested.evidence().recipient()) + .find(|value| value.report.recipient() == requested.recipient()) .ok_or(OperationError::InvalidEvidence)? .report; if actual != requested { @@ -126,7 +126,7 @@ impl Journal<'_> { ) .await?; let existing = deliveries.attempts.iter().position(|value| { - value.work().evidence().recipient() == evidence.recipient() + Some(value.work().recipient()) == evidence.target().recipient() && value.intent().request_id() == request.intent().request_id() }); let observations = Observations::read( @@ -160,8 +160,8 @@ 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())?; + deliveries.authorize_routes(bound, evidence.recipient()?)?; + let ordinals = deliveries.ordinals(evidence.recipient()?, request.intent())?; if current.observed_at() < actual.queued_at() || deliveries .attempts @@ -405,8 +405,7 @@ impl Journal<'_> { .attempts .iter() .position(|value| { - value.work().evidence().recipient() == recipient - && value.intent().request_id() == &request + value.work().recipient() == recipient && value.intent().request_id() == &request }) .map(|index| deliveries.attempts.remove(index))) } diff --git a/crates/storage_sqlite/src/workspace/evidence.rs b/crates/storage_sqlite/src/workspace/evidence.rs @@ -5,13 +5,18 @@ use super::{ }; use radroots_domain::TransactionId; use radroots_storage::command::protected::issuance::EvidenceManifest; -use radroots_storage::command::{EvidenceReceipt, OperationError, SealEvidence, SigningAttempt}; +use radroots_storage::command::{ + ArtifactEvidence, EvidenceReceipt, OperationError, SigningAttempt, +}; use sqlx::{Row, SqliteConnection}; use zeroize::Zeroizing; -pub(super) const TABLE: &str = "CREATE TABLE seal_evidence (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 4), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 65536), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES signing_attempts(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; -pub(super) const PARTS: &str = "CREATE TABLE seal_evidence_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 4), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,part), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES seal_evidence(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; -pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX seal_evidence_transaction_identity ON seal_evidence(workspace,transaction_id)"; +pub(super) const TABLE: &str = "CREATE TABLE artifact_evidence (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL, attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 4), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 65536), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key), FOREIGN KEY(workspace,operation_id,artifact_key) REFERENCES signing_attempts(workspace,operation_id,artifact_key)) STRICT, WITHOUT ROWID"; +pub(super) const TABLE_V8: &str = "CREATE TABLE seal_evidence (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 4), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 65536), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES signing_attempts(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; +pub(super) const PARTS: &str = "CREATE TABLE artifact_evidence_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 4), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key,part), FOREIGN KEY(workspace,operation_id,artifact_key) REFERENCES artifact_evidence(workspace,operation_id,artifact_key)) STRICT, WITHOUT ROWID"; +pub(super) const PARTS_V8: &str = "CREATE TABLE seal_evidence_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 4), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,part), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES seal_evidence(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; +pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX artifact_evidence_transaction_identity ON artifact_evidence(workspace,transaction_id)"; +pub(super) const TX_INDEX_V8: &str = "CREATE UNIQUE INDEX seal_evidence_transaction_identity ON seal_evidence(workspace,transaction_id)"; const MAX_PROTECTED_TOTAL: usize = 1024 * 1024; pub(super) struct ProtectedEvidence { pub manifest: Vec<u8>, @@ -21,7 +26,7 @@ pub(super) struct ProtectedEvidence { } pub(super) async fn protect( attempt: &SigningAttempt, - evidence: &SealEvidence, + evidence: &ArtifactEvidence, transaction: TransactionId, crypto: &WorkspaceCrypto, ) -> Result<ProtectedEvidence, OperationError> { @@ -60,10 +65,10 @@ pub(super) async fn read( connection: &mut SqliteConnection, attempt: &SigningAttempt, crypto: &WorkspaceCrypto, -) -> Result<Option<(SealEvidence, ProtectedEvidence)>, OperationError> { +) -> Result<Option<(ArtifactEvidence, ProtectedEvidence)>, OperationError> { let scope = attempt::scope(attempt)?; - let row=sqlx::query("SELECT CASE WHEN length(attempt_id)=32 THEN attempt_id END,CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(evidence_digest)=32 THEN evidence_digest 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 seal_evidence WHERE workspace=? AND operation_id=? AND recipient=?") - .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let row=sqlx::query(attempt::sql(connection, "SELECT CASE WHEN length(attempt_id)=32 THEN attempt_id END,CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(evidence_digest)=32 THEN evidence_digest 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 seal_evidence WHERE workspace=? AND operation_id=? AND recipient=?").await?) + .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; let Some(row) = row else { return Ok(None); }; @@ -107,13 +112,13 @@ pub(super) async fn read( { return Err(OperationError::RecoveryRequired); } - let (parts,total):(i64,i64)=sqlx::query_as("SELECT count(*),coalesce(sum(length(protected)),0) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=?") - .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let (parts,total):(i64,i64)=sqlx::query_as(attempt::sql(connection, "SELECT count(*),coalesce(sum(length(protected)),0) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=?").await?) + .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; if parts != count || total <= 0 || total > (MAX_PROTECTED_TOTAL - manifest.len()) as i64 { return Err(OperationError::RecoveryRequired); } - let rows=sqlx::query("SELECT part,CASE WHEN length(protected)>0 AND length(protected)<=262144 AND (SELECT coalesce(sum(length(p.protected)),0) FROM seal_evidence_parts p WHERE p.workspace=seal_evidence_parts.workspace AND p.operation_id=seal_evidence_parts.operation_id AND p.recipient=seal_evidence_parts.recipient)<=1048576 THEN protected END FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=? ORDER BY part LIMIT 5") - .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).fetch_all(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let rows=sqlx::query(attempt::sql(connection, "SELECT part,CASE WHEN length(protected)>0 AND length(protected)<=262144 AND (SELECT coalesce(sum(length(p.protected)),0) FROM seal_evidence_parts p WHERE p.workspace=seal_evidence_parts.workspace AND p.operation_id=seal_evidence_parts.operation_id AND p.recipient=seal_evidence_parts.recipient)<=1048576 THEN protected END FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=? ORDER BY part LIMIT 5").await?) + .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_all(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; if rows.len() != count as usize { return Err(OperationError::RecoveryRequired); } @@ -165,11 +170,11 @@ pub(super) async fn insert( value: &ProtectedEvidence, ) -> Result<(), OperationError> { let receipt = value.receipt; - sqlx::query("INSERT INTO seal_evidence(workspace,operation_id,recipient,attempt_id,event_id,evidence_digest,transaction_id,part_count,byte_count,protected) VALUES(?,?,?,?,?,?,?,?,?,?)") - .bind(receipt.workspace_id().as_bytes().as_slice()).bind(receipt.operation_id().as_bytes().as_slice()).bind(receipt.recipient().as_bytes().as_slice()).bind(receipt.attempt_id().as_bytes().as_slice()).bind(receipt.event_id().as_bytes().as_slice()).bind(receipt.digest().as_slice()).bind(receipt.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(attempt::sql(connection, "INSERT INTO seal_evidence(workspace,operation_id,recipient,attempt_id,event_id,evidence_digest,transaction_id,part_count,byte_count,protected) VALUES(?,?,?,?,?,?,?,?,?,?)").await?) + .bind(receipt.workspace_id().as_bytes().as_slice()).bind(receipt.operation_id().as_bytes().as_slice()).bind(receipt.target().key().as_slice()).bind(receipt.attempt_id().as_bytes().as_slice()).bind(receipt.event_id().as_bytes().as_slice()).bind(receipt.digest().as_slice()).bind(receipt.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 seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,?,?)") - .bind(receipt.workspace_id().as_bytes().as_slice()).bind(receipt.operation_id().as_bytes().as_slice()).bind(receipt.recipient().as_bytes().as_slice()).bind((index+1) as i64).bind(part).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; + sqlx::query(attempt::sql(connection, "INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,?,?)").await?) + .bind(receipt.workspace_id().as_bytes().as_slice()).bind(receipt.operation_id().as_bytes().as_slice()).bind(receipt.target().key().as_slice()).bind((index+1) as i64).bind(part).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; } Ok(()) } @@ -185,17 +190,15 @@ pub(super) async fn unchanged_scope( scope: IssuanceScope, value: Option<&ProtectedEvidence>, ) -> Result<(), OperationError> { - let count: i64 = sqlx::query_scalar( - "SELECT count(*) FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=?", - ) + let count: i64 = sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=?").await?) .bind(scope.workspace.as_bytes().as_slice()) .bind(scope.operation.as_bytes().as_slice()) - .bind(scope.recipient.as_bytes().as_slice()) + .bind(scope.target.key().as_slice()) .fetch_one(&mut *connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - let parts:i64=sqlx::query_scalar("SELECT count(*) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=?") - .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let parts:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=?").await?) + .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; let Some(value) = value else { return if count == 0 && parts == 0 { Ok(()) @@ -204,14 +207,14 @@ pub(super) async fn unchanged_scope( }; }; let receipt = value.receipt; - let matched:i64=sqlx::query_scalar("SELECT count(*) FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=? AND attempt_id=? AND event_id=? AND evidence_digest=? AND transaction_id=? AND part_count=? AND byte_count=? AND protected=?") - .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).bind(receipt.attempt_id().as_bytes().as_slice()).bind(receipt.event_id().as_bytes().as_slice()).bind(receipt.digest().as_slice()).bind(receipt.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let matched:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=? AND attempt_id=? AND event_id=? AND evidence_digest=? AND transaction_id=? AND part_count=? AND byte_count=? AND protected=?").await?) + .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind(receipt.attempt_id().as_bytes().as_slice()).bind(receipt.event_id().as_bytes().as_slice()).bind(receipt.digest().as_slice()).bind(receipt.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; if count != 1 || matched != 1 || parts != value.parts.len() as i64 { return Err(OperationError::RecoveryRequired); } for (index, part) in value.parts.iter().enumerate() { - let matched:i64=sqlx::query_scalar("SELECT count(*) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=? AND part=? AND protected=?") - .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).bind((index+1) as i64).bind(part).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let matched:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=? AND part=? AND protected=?").await?) + .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind((index+1) as i64).bind(part).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; if matched != 1 { return Err(OperationError::RecoveryRequired); } diff --git a/crates/storage_sqlite/src/workspace/installation.rs b/crates/storage_sqlite/src/workspace/installation.rs @@ -26,7 +26,8 @@ pub(super) const OP_INDEX: &str = pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX chat_message_transaction_identity ON chat_messages(workspace,transaction_id)"; pub(super) const THREAD_INDEX: &str = "CREATE INDEX chat_message_thread ON chat_messages(workspace,thread_id,message_id)"; -pub(super) const WORK: &str = "CREATE TABLE chat_publication_work (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), installation_transaction BLOB NOT NULL CHECK(length(installation_transaction)=32), capture_transaction BLOB NOT NULL CHECK(length(capture_transaction)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id) REFERENCES chat_messages(workspace,operation_id), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES seal_evidence(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; +pub(super) const WORK: &str = "CREATE TABLE chat_publication_work (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), installation_transaction BLOB NOT NULL CHECK(length(installation_transaction)=32), capture_transaction BLOB NOT NULL CHECK(length(capture_transaction)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id) REFERENCES chat_messages(workspace,operation_id), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES artifact_evidence(workspace,operation_id,artifact_key)) STRICT, WITHOUT ROWID"; +pub(super) const WORK_V8: &str = "CREATE TABLE chat_publication_work (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL CHECK(length(recipient)=32), installation_transaction BLOB NOT NULL CHECK(length(installation_transaction)=32), capture_transaction BLOB NOT NULL CHECK(length(capture_transaction)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id) REFERENCES chat_messages(workspace,operation_id), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES seal_evidence(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; #[derive(Serialize, Deserialize, Eq, PartialEq)] #[serde(deny_unknown_fields)] @@ -42,12 +43,12 @@ pub(super) struct EvidenceRef { observed_at: Option<u64>, } impl EvidenceRef { - pub(super) fn new(value: EvidenceReceipt) -> Self { + pub(super) fn new(value: EvidenceReceipt, recipient: PublicKey) -> Self { Self { workspace: value.workspace_id(), operation: value.operation_id(), command: value.command_digest(), - recipient: value.recipient(), + recipient, attempt: value.attempt_id(), event: value.event_id(), digest: *value.digest(), @@ -80,7 +81,7 @@ impl MessageRecord { plan_transaction: value.plan_transaction_id(), transaction: value.transaction_id(), installed_at: value.installed_at(), - basis: EvidenceRef::new(value.basis()), + basis: EvidenceRef::new(value.basis(), value.basis().recipient()?), }) } } @@ -108,7 +109,7 @@ impl WorkRecord { plan_transaction: installed.plan_transaction_id(), transaction: value.transaction_id(), queued_at: value.queued_at(), - evidence: EvidenceRef::new(value.evidence()), + evidence: EvidenceRef::new(value.evidence(), value.recipient()), } } } @@ -131,7 +132,7 @@ fn scope(bound: &BoundSigningPlan, receipt: EvidenceReceipt) -> IssuanceScope { operation: receipt.operation_id(), plan_digest: *bound.plan().digest(), attempt: receipt.attempt_id(), - recipient: receipt.recipient(), + target: receipt.target(), } } fn bytes(row: &sqlx::sqlite::SqliteRow, index: usize) -> Result<Vec<u8>, OperationError> { @@ -145,7 +146,7 @@ fn obtained( ) -> Result<EvidenceReceipt, OperationError> { graph .reports() - .find(|value| value.recipient() == recipient) + .find(|value| value.target().recipient() == Some(recipient)) .and_then(|value| value.obtained()) .ok_or(OperationError::RecoveryRequired) } @@ -207,7 +208,10 @@ impl Records { }; let mut work = Vec::new(); if let Some(bound) = graph.bound_plan() { - for recipient in graph.reports().map(|value| value.recipient()) { + for recipient in graph + .reports() + .filter_map(|value| value.target().recipient()) + { let row=sqlx::query("SELECT CASE WHEN length(installation_transaction)=32 THEN installation_transaction END,CASE WHEN length(capture_transaction)=32 THEN capture_transaction END,CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(evidence_digest)=32 THEN evidence_digest END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_publication_work WHERE workspace=? AND operation_id=? AND recipient=?") .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(recipient.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; if let Some(row) = row { @@ -280,7 +284,7 @@ impl Records { let work = value.report; let evidence = work.evidence(); let count:i64=sqlx::query_scalar("SELECT count(*) FROM chat_publication_work WHERE workspace=? AND operation_id=? AND recipient=? AND installation_transaction=? AND capture_transaction=? AND event_id=? AND evidence_digest=? AND transaction_id=? AND protected=?") - .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(evidence.recipient().as_bytes().as_slice()).bind(work.installation_transaction_id().as_bytes().as_slice()).bind(evidence.transaction_id().as_bytes().as_slice()).bind(evidence.event_id().as_bytes().as_slice()).bind(evidence.digest().as_slice()).bind(work.transaction_id().as_bytes().as_slice()).bind(&value.protected).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; + .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(evidence.recipient()?.as_bytes().as_slice()).bind(work.installation_transaction_id().as_bytes().as_slice()).bind(evidence.transaction_id().as_bytes().as_slice()).bind(evidence.event_id().as_bytes().as_slice()).bind(evidence.digest().as_slice()).bind(work.transaction_id().as_bytes().as_slice()).bind(&value.protected).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; if count != 1 { return Err(OperationError::RecoveryRequired); } @@ -348,7 +352,7 @@ pub(super) async fn insert_work( let work = value.report; let evidence = work.evidence(); sqlx::query("INSERT INTO chat_publication_work(workspace,operation_id,recipient,installation_transaction,capture_transaction,event_id,evidence_digest,transaction_id,protected) VALUES(?,?,?,?,?,?,?,?,?)") - .bind(evidence.workspace_id().as_bytes().as_slice()).bind(evidence.operation_id().as_bytes().as_slice()).bind(evidence.recipient().as_bytes().as_slice()).bind(work.installation_transaction_id().as_bytes().as_slice()).bind(evidence.transaction_id().as_bytes().as_slice()).bind(evidence.event_id().as_bytes().as_slice()).bind(evidence.digest().as_slice()).bind(work.transaction_id().as_bytes().as_slice()).bind(&value.protected).execute(connection).await.map_err(write_error)?; + .bind(evidence.workspace_id().as_bytes().as_slice()).bind(evidence.operation_id().as_bytes().as_slice()).bind(evidence.recipient()?.as_bytes().as_slice()).bind(work.installation_transaction_id().as_bytes().as_slice()).bind(evidence.transaction_id().as_bytes().as_slice()).bind(evidence.event_id().as_bytes().as_slice()).bind(evidence.digest().as_slice()).bind(work.transaction_id().as_bytes().as_slice()).bind(&value.protected).execute(connection).await.map_err(write_error)?; Ok(()) } fn write_error(error: sqlx::Error) -> OperationError { @@ -397,7 +401,7 @@ impl Journal<'_> { !records .work .iter() - .any(|value| value.report.evidence().recipient() == evidence.recipient()) + .any(|value| value.report.evidence().target() == evidence.target()) }) .collect(); let fresh = records.message.is_none() || !missing.is_empty(); diff --git a/crates/storage_sqlite/src/workspace/issuance.rs b/crates/storage_sqlite/src/workspace/issuance.rs @@ -8,10 +8,11 @@ use super::{ snapshot::RetainedFacts, worker, }; -use radroots_domain::{CommandDigest, OperationId, PublicKey, SigningAttemptId, TransactionId}; +use radroots_domain::{CommandDigest, OperationId, SigningAttemptId, TransactionId}; +use radroots_storage::command::SigningTarget; use radroots_storage::command::{ - BoundSigningPlan, CapturedSeal, ClaimAttemptOutcome, ClaimAttemptRequest, CommitAttempt, - EvidenceCaptureOutcome, OperationError, SealEvidence, SigningAttempt, + ArtifactEvidence, BoundSigningPlan, CapturedArtifact, ClaimAttemptOutcome, ClaimAttemptRequest, + CommitAttempt, EvidenceCaptureOutcome, OperationError, SigningAttempt, }; use sqlx::{Connection, SqliteConnection}; @@ -59,6 +60,7 @@ impl Journal<'_> { proof: AttachmentProof, ) -> Result<ClaimAttemptOutcome, OperationError> { let (grant_record, grant, current) = self.access(request.binding(), &proof).await?; + attempt::require_target(self.connection, request.target()).await?; let loaded = self .load_issuance_plan(request.operation_id(), request.command_digest()) .await? @@ -79,7 +81,7 @@ impl Journal<'_> { self.connection, self.selected, bound, - request.recipient(), + request.target(), self.crypto, ) .await?; @@ -104,7 +106,7 @@ impl Journal<'_> { ( SigningAttempt::from_committed_store( bound, - request.recipient(), + request.target(), id, transaction, time, @@ -121,7 +123,7 @@ impl Journal<'_> { } let snapshot = SigningAttempt::from_committed_store( bound, - request.recipient(), + request.target(), SigningAttemptId::from_bytes(super::random()?), TransactionId::from_bytes(super::random()?), current.observed_at(), @@ -181,7 +183,7 @@ impl Journal<'_> { &mut transaction, self.selected, request.operation_id(), - request.recipient(), + request.target(), ) .await?; attempt::insert(&mut transaction, &snapshot, &protected).await?; @@ -234,7 +236,7 @@ impl Journal<'_> { self.connection, self.selected, loaded.bound, - request.recipient(), + request.target(), self.crypto, ) .await?; @@ -242,7 +244,7 @@ impl Journal<'_> { Some((id, transaction, time, protected)) => Some(( SigningAttempt::from_committed_store( bound, - request.recipient(), + request.target(), id, transaction, time, @@ -312,7 +314,7 @@ impl Journal<'_> { &mut transaction, self.selected, request.operation_id(), - request.recipient(), + request.target(), ) .await?; } @@ -359,7 +361,7 @@ impl Journal<'_> { &mut self, input: AttachmentInput, proof: AttachmentProof, - supplied: SealEvidence, + supplied: ArtifactEvidence, ) -> Result<EvidenceCaptureOutcome, OperationError> { let (record, grant) = self.capture_access(&input, &proof).await?; if supplied.workspace_id() != self.selected.workspace_id() { @@ -377,7 +379,7 @@ impl Journal<'_> { self.connection, self.selected, bound, - supplied.recipient(), + supplied.target(), self.crypto, ) .await?; @@ -385,7 +387,7 @@ impl Journal<'_> { claim.ok_or(OperationError::RecoveryRequired)?; let snapshot = SigningAttempt::from_committed_store( bound, - supplied.recipient(), + supplied.target(), id, claim_transaction, claimed_at, @@ -395,7 +397,7 @@ impl Journal<'_> { } // The supplied typed value was already independently verified. Recheck // it against the backend's actual immutable claim, not its descriptor. - let checked = SealEvidence::verify( + let checked = ArtifactEvidence::verify( &snapshot, supplied.raw_json(), supplied.observed_at_unix_ms(), @@ -480,7 +482,7 @@ impl Journal<'_> { &mut self, request: ClaimAttemptRequest, proof: AttachmentProof, - ) -> Result<Option<CapturedSeal>, OperationError> { + ) -> Result<Option<CapturedArtifact>, OperationError> { let (record, grant, _) = self.access(request.binding(), &proof).await?; let loaded = self .load_issuance_plan(request.operation_id(), request.command_digest()) @@ -497,14 +499,14 @@ impl Journal<'_> { self.connection, self.selected, loaded.bound, - request.recipient(), + request.target(), self.crypto, ) .await?; if let Some((id, transaction, time, protected)) = value { let snapshot = SigningAttempt::from_committed_store( bound, - request.recipient(), + request.target(), id, transaction, time, @@ -579,7 +581,7 @@ impl Journal<'_> { &mut transaction, self.selected, request.operation_id(), - request.recipient(), + request.target(), ) .await?; } @@ -593,7 +595,7 @@ impl Journal<'_> { checked?; match retained { Some((attempt, _, _, _, Some((evidence, protected)))) => { - Ok(Some(CapturedSeal::from_committed_store( + Ok(Some(CapturedArtifact::from_committed_store( attempt, evidence, protected.receipt.transaction_id(), @@ -607,10 +609,11 @@ pub(super) async fn absent_claim( connection: &mut SqliteConnection, selected: &AttachmentInput, operation: OperationId, - recipient: PublicKey, + target: impl Into<SigningTarget>, ) -> Result<(), OperationError> { - let count:i64=sqlx::query_scalar("SELECT (SELECT count(*) FROM signing_attempts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3)+(SELECT count(*) FROM seal_evidence WHERE workspace=?1 AND operation_id=?2 AND recipient=?3)+(SELECT count(*) FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3)") - .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(recipient.as_bytes().as_slice()).fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; + let target = target.into(); + let count:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT (SELECT count(*) FROM signing_attempts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3)+(SELECT count(*) FROM seal_evidence WHERE workspace=?1 AND operation_id=?2 AND recipient=?3)+(SELECT count(*) FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3)").await?) + .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(target.key().as_slice()).fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; if count != 0 { return Err(OperationError::RecoveryRequired); } diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs @@ -140,7 +140,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { &'a self, input: AttachmentInput, proof: &'a AttachmentProof, - evidence: &'a radroots_storage::command::SealEvidence, + evidence: &'a radroots_storage::command::ArtifactEvidence, ) -> BoxFuture< 'a, Result< @@ -282,7 +282,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { &'a self, input: AttachmentInput, proof: &'a AttachmentProof, - evidence: &'a radroots_storage::command::SealEvidence, + evidence: &'a radroots_storage::command::ArtifactEvidence, ) -> BoxFuture< 'a, Result< @@ -299,7 +299,7 @@ impl radroots_storage::command::OperationJournal for NativeWorkspace { ) -> BoxFuture< '_, Result< - Option<radroots_storage::command::CapturedSeal>, + Option<radroots_storage::command::CapturedArtifact>, radroots_storage::command::OperationError, >, > { diff --git a/crates/storage_sqlite/src/workspace/operation.rs b/crates/storage_sqlite/src/workspace/operation.rs @@ -129,7 +129,7 @@ pub(super) async fn absent( selected: &AttachmentInput, operation: OperationId, ) -> Result<(), OperationError> { - let retained: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM operations WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM signing_plans WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM signing_plan_parts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM signing_attempts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM seal_evidence WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_messages WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_publication_work WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_delivery_observations WHERE workspace=?1 AND operation_id=?2)") + let retained: bool = sqlx::query_scalar(super::attempt::sql(connection, "SELECT EXISTS(SELECT 1 FROM operations WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM signing_plans WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM signing_plan_parts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM signing_attempts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM seal_evidence WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_messages WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_publication_work WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2) OR EXISTS(SELECT 1 FROM chat_delivery_observations WHERE workspace=?1 AND operation_id=?2)").await?) .bind(selected.workspace_id().as_bytes().as_slice()) .bind(operation.as_bytes().as_slice()) .fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; diff --git a/crates/storage_sqlite/src/workspace/recovery.rs b/crates/storage_sqlite/src/workspace/recovery.rs @@ -3,7 +3,7 @@ use super::{ AttachmentInput, AttachmentProof, WorkspaceClock, WorkspaceCrypto, admission::Journal, fs::Namespace, record::GrantRecord, worker, }; -use radroots_storage::command::{EvidenceCaptureOutcome, OperationError, SealEvidence}; +use radroots_storage::command::{ArtifactEvidence, EvidenceCaptureOutcome, OperationError}; use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions}; pub(super) struct RecoveryAuthorization { @@ -25,7 +25,7 @@ impl RecoveryTurn<'_> { &mut self, input: AttachmentInput, proof: AttachmentProof, - evidence: SealEvidence, + evidence: ArtifactEvidence, ) -> Result<EvidenceCaptureOutcome, OperationError> { if input != *self.selected { return Err(OperationError::Unauthorized); diff --git a/crates/storage_sqlite/src/workspace/snapshot.rs b/crates/storage_sqlite/src/workspace/snapshot.rs @@ -12,28 +12,29 @@ use super::{ plan::ProtectedPlan, }; use radroots_domain::{CommandDigest, EnvelopeEventId, OperationId, PublicKey, UnixSeconds}; +use radroots_storage::command::SigningTarget; use radroots_storage::command::{ - BoundSigningPlan, ClaimSnapshot, DeliveryAttemptSummary, OperationError, OperationSnapshot, - RecipientSnapshot, RetainedOperation, SealEvidence, SigningAttempt, + ArtifactEvidence, ArtifactSnapshot, BoundSigningPlan, ClaimSnapshot, DeliveryAttemptSummary, + OperationError, OperationSnapshot, RetainedOperation, SigningAttempt, }; use sqlx::{Connection, SqliteConnection}; -struct SeenRecipient { - report: RecipientSnapshot, +struct SeenArtifact { + report: ArtifactSnapshot, claim: Option<Vec<u8>>, evidence: Option<ProtectedEvidence>, - obtained: Option<SealEvidence>, + obtained: Option<ArtifactEvidence>, } pub(super) struct RetainedGraph { retained: Option<(RetainedOperation, Vec<u8>)>, protected_plan: Option<ProtectedPlan>, - recipients: Vec<SeenRecipient>, + artifacts: Vec<SeenArtifact>, } impl RetainedGraph { - pub(super) fn obtained(&self, recipient: PublicKey) -> Option<&SealEvidence> { - self.recipients + pub(super) fn obtained(&self, recipient: PublicKey) -> Option<&ArtifactEvidence> { + self.artifacts .iter() - .find(|seen| seen.report.recipient() == recipient) + .find(|seen| seen.report.target().recipient() == Some(recipient)) .and_then(|seen| seen.obtained.as_ref()) } pub(super) fn bound_plan(&self) -> Option<&BoundSigningPlan> { @@ -41,8 +42,8 @@ impl RetainedGraph { .as_ref() .and_then(|(value, _)| value.bound_plan()) } - pub(super) fn reports(&self) -> impl Iterator<Item = RecipientSnapshot> + '_ { - self.recipients.iter().map(|value| value.report) + pub(super) fn reports(&self) -> impl Iterator<Item = ArtifactSnapshot> + '_ { + self.artifacts.iter().map(|value| value.report) } pub(super) async fn read( connection: &mut SqliteConnection, @@ -53,7 +54,7 @@ impl RetainedGraph { crypto: &WorkspaceCrypto, ) -> Result<Self, OperationError> { let original = operation::read(connection, selected, operation_id, crypto).await?; - let mut recipients = Vec::new(); + let mut artifacts = Vec::new(); let mut protected_plan = None; let retained = if let Some((prepared, protected)) = original { operation::check_digest(&prepared, binding.actor(), expected_digest)?; @@ -63,22 +64,24 @@ impl RetainedGraph { protected_plan = Some(protected); let mut bound = BoundSigningPlan::from_committed_store(prepared, plan, transaction, time)?; - let keys: Vec<PublicKey> = bound - .chat_plan()? - .seals() - .iter() - .map(|seal| seal.recipient()) - .collect(); + let keys = match bound.plan().chat() { + Some(plan) => plan + .seals() + .iter() + .map(|seal| SigningTarget::BusinessSeal(seal.recipient())) + .collect::<Vec<_>>(), + None => vec![SigningTarget::PublicEvent], + }; for recipient in keys { let (returned, claim) = attempt::read(connection, selected, bound, recipient, crypto).await?; - let expected = returned - .chat_plan()? - .seals() - .iter() - .find(|seal| seal.recipient() == recipient) - .map(|seal| EnvelopeEventId::from_bytes(seal.event_id())) - .ok_or(OperationError::RecoveryRequired)?; + let expected = EnvelopeEventId::from_bytes( + returned + .plan() + .artifact(recipient) + .map_err(|_| OperationError::RecoveryRequired)? + .event_id(), + ); if let Some((id, transaction, time, protected)) = claim { let attempt = SigningAttempt::from_committed_store( returned, @@ -95,8 +98,8 @@ impl RetainedGraph { } None => (None, None, None), }; - recipients.push(SeenRecipient { - report: RecipientSnapshot::from_store_report( + artifacts.push(SeenArtifact { + report: ArtifactSnapshot::from_store_report( recipient, Some(expected), Some(claim), @@ -108,8 +111,8 @@ impl RetainedGraph { }); bound = attempt.into_bound_plan(); } else { - recipients.push(SeenRecipient { - report: RecipientSnapshot::from_store_report( + artifacts.push(SeenArtifact { + report: ArtifactSnapshot::from_store_report( recipient, Some(expected), None, @@ -124,13 +127,18 @@ impl RetainedGraph { } RetainedOperation::Planned(Box::new(bound)) } else { - let command = prepared.request().chat_command()?; - let mut keys = vec![command.context().actor().participant(), command.peer()]; - keys.sort_unstable(); + let mut keys = match prepared.request().command().chat() { + Some(command) => vec![ + SigningTarget::BusinessSeal(command.context().actor().participant()), + SigningTarget::BusinessSeal(command.peer()), + ], + None => vec![SigningTarget::PublicEvent], + }; + keys.sort_unstable_by_key(|target| target.key()); keys.dedup(); for recipient in keys { - recipients.push(SeenRecipient { - report: RecipientSnapshot::from_store_report(recipient, None, None, None), + artifacts.push(SeenArtifact { + report: ArtifactSnapshot::from_store_report(recipient, None, None, None), claim: None, evidence: None, obtained: None, @@ -145,7 +153,7 @@ impl RetainedGraph { Ok(Self { retained, protected_plan, - recipients, + artifacts, }) } pub(super) async fn unchanged( @@ -157,7 +165,7 @@ impl RetainedGraph { if let Some((source, protected)) = &self.retained { operation::unchanged(connection, source.prepared(), protected).await?; plan::unchanged(connection, source.prepared(), self.protected_plan.as_ref()).await?; - for seen in &self.recipients { + for seen in &self.artifacts { if let (Some(claim), Some(protected)) = (seen.report.claim(), &seen.claim) { attempt::unchanged_snapshot(connection, claim, protected).await?; let scope = IssuanceScope { @@ -165,23 +173,22 @@ impl RetainedGraph { operation: claim.operation_id(), plan_digest: *claim.plan_digest(), attempt: claim.attempt_id(), - recipient: claim.recipient(), + target: claim.target(), }; evidence::unchanged_scope(connection, scope, seen.evidence.as_ref()).await?; } else { - absent_claim(connection, selected, operation_id, seen.report.recipient()) - .await?; + absent_claim(connection, selected, operation_id, seen.report.target()).await?; } } graph_counts( connection, selected.workspace_id().as_bytes(), operation_id.as_bytes(), - &self.recipients, + &self.artifacts, ) .await?; } else { - let count:i64=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM operations WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM signing_plans WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM signing_plan_parts WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM signing_attempts WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM seal_evidence WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2)") + let count:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT EXISTS(SELECT 1 FROM operations WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM signing_plans WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM signing_plan_parts WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM signing_attempts WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM seal_evidence WHERE workspace=?1 AND operation_id=?2)+EXISTS(SELECT 1 FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2)").await?) .bind(selected.workspace_id().as_bytes().as_slice()).bind(operation_id.as_bytes().as_slice()).fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; if count != 0 { return Err(OperationError::RecoveryRequired); @@ -196,10 +203,7 @@ impl RetainedGraph { match self.retained { Some((source, _)) => OperationSnapshot::from_store_report( source, - self.recipients - .into_iter() - .map(|seen| seen.report) - .collect(), + self.artifacts.into_iter().map(|seen| seen.report).collect(), observed, ) .map(Some), @@ -339,21 +343,18 @@ async fn graph_counts( connection: &mut SqliteConnection, workspace: &[u8; 32], operation: &[u8; 32], - recipients: &[SeenRecipient], + artifacts: &[SeenArtifact], ) -> Result<(), OperationError> { // The valid graph has at most two claims, two obtained manifests and eight // data parts. One excess sentinel is sufficient to reject arbitrary extras. - let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM (SELECT 1 FROM signing_attempts WHERE workspace=?1 AND operation_id=?2 LIMIT 3)),(SELECT count(*) FROM (SELECT 1 FROM seal_evidence WHERE workspace=?1 AND operation_id=?2 LIMIT 3)),(SELECT count(*) FROM (SELECT 1 FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2 LIMIT 9))") + let counts:(i64,i64,i64)=sqlx::query_as(attempt::sql(connection, "SELECT (SELECT count(*) FROM (SELECT 1 FROM signing_attempts WHERE workspace=?1 AND operation_id=?2 LIMIT 3)),(SELECT count(*) FROM (SELECT 1 FROM seal_evidence WHERE workspace=?1 AND operation_id=?2 LIMIT 3)),(SELECT count(*) FROM (SELECT 1 FROM seal_evidence_parts WHERE workspace=?1 AND operation_id=?2 LIMIT 9))").await?) .bind(workspace.as_slice()).bind(operation.as_slice()).fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; - let claims = recipients - .iter() - .filter(|seen| seen.claim.is_some()) - .count() as i64; - let evidence = recipients + let claims = artifacts.iter().filter(|seen| seen.claim.is_some()).count() as i64; + let evidence = artifacts .iter() .filter(|seen| seen.evidence.is_some()) .count() as i64; - let parts = recipients + let parts = artifacts .iter() .filter_map(|seen| seen.evidence.as_ref()) .map(|value| value.parts.len() as i64) diff --git a/crates/storage_sqlite/src/workspace/tests/issuance_records.rs b/crates/storage_sqlite/src/workspace/tests/issuance_records.rs @@ -13,8 +13,9 @@ use radroots_protocol::{ plan::SigningReplay, }; use radroots_storage::command::{ - AdmissionOutcome, AdmissionRequest, BoundSigningPlan, ClaimAttemptOutcome, ClaimAttemptRequest, - EvidenceCaptureOutcome, OperationJournal, PlanBindingOutcome, SealEvidence, SigningAttempt, + AdmissionOutcome, AdmissionRequest, ArtifactEvidence, BoundSigningPlan, ClaimAttemptOutcome, + ClaimAttemptRequest, EvidenceCaptureOutcome, OperationJournal, PlanBindingOutcome, + SigningAttempt, }; use serde_json::{Value, json}; use sqlx::{Connection, SqliteConnection}; @@ -22,7 +23,7 @@ struct Issued { fixture: CryptoFixture, selected: AttachmentInput, attempt: SigningAttempt, - evidence: SealEvidence, + evidence: ArtifactEvidence, proof: AttachmentProof, path: std::path::PathBuf, } @@ -80,7 +81,7 @@ pub(in crate::workspace) async fn delivery_data() -> DeliveryData { let mut scalar = [0; 32]; scalar[31] = 3; let keys = nostr::Keys::new(nostr::SecretKey::from_slice(&scalar).unwrap()); - let recipient = nostr::PublicKey::from_slice(work.evidence().recipient().as_bytes()).unwrap(); + let recipient = nostr::PublicKey::from_slice(work.recipient().as_bytes()).unwrap(); let raw = nostr::UnsignedEvent { id: None, pubkey: keys.public_key(), @@ -262,7 +263,7 @@ impl Issued { .sign_with_keys(&keys) .unwrap(); signed.verify().unwrap(); - let evidence = SealEvidence::verify(&attempt, &signed.as_json(), None).unwrap(); + let evidence = ArtifactEvidence::verify(&attempt, &signed.as_json(), None).unwrap(); assert!(evidence.raw_json().len() > 16384); assert!(matches!( store @@ -423,7 +424,7 @@ async fn authenticated_attempt_headers_and_all_indexed_facts_are_checked_without for change in [ "UPDATE signing_attempts SET workspace=zeroblob(32)", "UPDATE signing_attempts SET operation_id=zeroblob(32)", - "UPDATE signing_attempts SET recipient=zeroblob(32)", + "UPDATE signing_attempts SET artifact_key=zeroblob(32)", "UPDATE signing_attempts SET attempt_id=zeroblob(32)", "UPDATE signing_attempts SET transaction_id=zeroblob(32)", "UPDATE signing_attempts SET plan_digest=zeroblob(32)", @@ -439,7 +440,7 @@ async fn authenticated_attempt_headers_and_all_indexed_facts_are_checked_without "{change}" ); transaction.rollback().await.unwrap(); - sqlx::query("UPDATE signing_attempts SET workspace=?,operation_id=?,recipient=?,attempt_id=?,transaction_id=?,plan_digest=?,intent_digest=?,protected=?").bind(identity.workspace_id().as_bytes().as_slice()).bind(identity.operation_id().as_bytes().as_slice()).bind(participant().as_bytes().as_slice()).bind(issued.attempt.attempt_id().as_bytes().as_slice()).bind(issued.attempt.transaction_id().as_bytes().as_slice()).bind(issued.attempt.bound_plan().plan().digest().as_slice()).bind(issued.attempt.binding().digest().as_slice()).bind(&original).execute(&mut database).await.unwrap(); + sqlx::query("UPDATE signing_attempts SET workspace=?,operation_id=?,artifact_key=?,attempt_id=?,transaction_id=?,plan_digest=?,intent_digest=?,protected=?").bind(identity.workspace_id().as_bytes().as_slice()).bind(identity.operation_id().as_bytes().as_slice()).bind(participant().as_bytes().as_slice()).bind(issued.attempt.attempt_id().as_bytes().as_slice()).bind(issued.attempt.transaction_id().as_bytes().as_slice()).bind(issued.attempt.bound_plan().plan().digest().as_slice()).bind(issued.attempt.binding().digest().as_slice()).bind(&original).execute(&mut database).await.unwrap(); } database.close().await.unwrap(); } @@ -449,7 +450,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ let mut database = issued.database().await; let crypto = issued.fixture.crypto(); let scope = attempt_store::scope(&issued.attempt).unwrap(); - let original: Vec<u8> = sqlx::query_scalar("SELECT protected FROM seal_evidence") + let original: Vec<u8> = sqlx::query_scalar("SELECT protected FROM artifact_evidence") .fetch_one(&mut database) .await .unwrap(); @@ -490,7 +491,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ ) .await .unwrap(); - sqlx::query("UPDATE seal_evidence SET protected=?") + sqlx::query("UPDATE artifact_evidence SET protected=?") .bind(&protected) .execute(&mut database) .await @@ -500,7 +501,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ .err() .expect("inconsistent authenticated evidence must fail"); assert_eq!(error.code(), "recovery_required", "{field}"); - let retained: Vec<u8> = sqlx::query_scalar("SELECT protected FROM seal_evidence") + let retained: Vec<u8> = sqlx::query_scalar("SELECT protected FROM artifact_evidence") .fetch_one(&mut database) .await .unwrap(); @@ -527,7 +528,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ ) .await .unwrap(); - sqlx::query("UPDATE seal_evidence SET protected=?") + sqlx::query("UPDATE artifact_evidence SET protected=?") .bind(&protected) .execute(&mut database) .await @@ -540,27 +541,27 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ .code(), "recovery_required" ); - let retained: Vec<u8> = sqlx::query_scalar("SELECT protected FROM seal_evidence") + let retained: Vec<u8> = sqlx::query_scalar("SELECT protected FROM artifact_evidence") .fetch_one(&mut database) .await .unwrap(); assert_eq!(retained, protected); } - sqlx::query("UPDATE seal_evidence SET protected=?") + sqlx::query("UPDATE artifact_evidence SET protected=?") .bind(&original) .execute(&mut database) .await .unwrap(); - let header:(Vec<u8>,Vec<u8>,Vec<u8>,Vec<u8>,i64,i64)=sqlx::query_as("SELECT attempt_id,event_id,evidence_digest,transaction_id,part_count,byte_count FROM seal_evidence").fetch_one(&mut database).await.unwrap(); + let header:(Vec<u8>,Vec<u8>,Vec<u8>,Vec<u8>,i64,i64)=sqlx::query_as("SELECT attempt_id,event_id,evidence_digest,transaction_id,part_count,byte_count FROM artifact_evidence").fetch_one(&mut database).await.unwrap(); for change in [ - "UPDATE seal_evidence SET attempt_id=zeroblob(32)", - "UPDATE seal_evidence SET event_id=zeroblob(32)", - "UPDATE seal_evidence SET evidence_digest=zeroblob(32)", - "UPDATE seal_evidence SET transaction_id=zeroblob(32)", - "UPDATE seal_evidence SET part_count=5", - "UPDATE seal_evidence SET byte_count=65537", - "UPDATE seal_evidence SET part_count=1", - "UPDATE seal_evidence SET protected=zeroblob(262145)", + "UPDATE artifact_evidence SET attempt_id=zeroblob(32)", + "UPDATE artifact_evidence SET event_id=zeroblob(32)", + "UPDATE artifact_evidence SET evidence_digest=zeroblob(32)", + "UPDATE artifact_evidence SET transaction_id=zeroblob(32)", + "UPDATE artifact_evidence SET part_count=5", + "UPDATE artifact_evidence SET byte_count=65537", + "UPDATE artifact_evidence SET part_count=1", + "UPDATE artifact_evidence SET protected=zeroblob(262145)", ] { sqlx::query(change).execute(&mut database).await.unwrap(); assert_eq!( @@ -572,7 +573,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ "recovery_required", "{change}" ); - sqlx::query("UPDATE seal_evidence SET attempt_id=?,event_id=?,evidence_digest=?,transaction_id=?,part_count=?,byte_count=?,protected=?").bind(&header.0).bind(&header.1).bind(&header.2).bind(&header.3).bind(header.4).bind(header.5).bind(&original).execute(&mut database).await.unwrap(); + sqlx::query("UPDATE artifact_evidence SET attempt_id=?,event_id=?,evidence_digest=?,transaction_id=?,part_count=?,byte_count=?,protected=?").bind(&header.0).bind(&header.1).bind(&header.2).bind(&header.3).bind(header.4).bind(header.5).bind(&original).execute(&mut database).await.unwrap(); } // A valid protected manifest matching a changed SQL digest still cannot // redefine the hash of the original authenticated raw signature bytes. @@ -587,7 +588,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ ) .await .unwrap(); - sqlx::query("UPDATE seal_evidence SET evidence_digest=?,protected=?") + sqlx::query("UPDATE artifact_evidence SET evidence_digest=?,protected=?") .bind([9u8; 32].as_slice()) .bind(&protected) .execute(&mut database) @@ -601,49 +602,49 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ .code(), "recovery_required" ); - sqlx::query("UPDATE seal_evidence SET evidence_digest=?,protected=?") + sqlx::query("UPDATE artifact_evidence SET evidence_digest=?,protected=?") .bind(&header.2) .bind(&original) .execute(&mut database) .await .unwrap(); let parts: Vec<(i64, Vec<u8>)> = - sqlx::query_as("SELECT part,protected FROM seal_evidence_parts ORDER BY part") + sqlx::query_as("SELECT part,protected FROM artifact_evidence_parts ORDER BY part") .fetch_all(&mut database) .await .unwrap(); assert!(parts.len() > 1); for fault in 0..5 { - sqlx::query("DELETE FROM seal_evidence_parts") + sqlx::query("DELETE FROM artifact_evidence_parts") .execute(&mut database) .await .unwrap(); for (part, protected) in &parts { - sqlx::query("INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,?,?)").bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).bind(part).bind(protected).execute(&mut database).await.unwrap(); + sqlx::query("INSERT INTO artifact_evidence_parts(workspace,operation_id,artifact_key,part,protected) VALUES(?,?,?,?,?)").bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind(part).bind(protected).execute(&mut database).await.unwrap(); } match fault { 0 => { - sqlx::query("DELETE FROM seal_evidence_parts WHERE part=1") + sqlx::query("DELETE FROM artifact_evidence_parts WHERE part=1") .execute(&mut database) .await .unwrap(); } 1 => { - sqlx::query("UPDATE seal_evidence_parts SET protected=zeroblob(0)") + sqlx::query("UPDATE artifact_evidence_parts SET protected=zeroblob(0)") .execute(&mut database) .await .unwrap(); } 2 => { sqlx::query( - "UPDATE seal_evidence_parts SET protected=zeroblob(1048577) WHERE part=1", + "UPDATE artifact_evidence_parts SET protected=zeroblob(1048577) WHERE part=1", ) .execute(&mut database) .await .unwrap(); } 3 => { - sqlx::query("UPDATE seal_evidence_parts SET part=0 WHERE part=1") + sqlx::query("UPDATE artifact_evidence_parts SET part=0 WHERE part=1") .execute(&mut database) .await .unwrap(); @@ -653,7 +654,7 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ .seal_issuance(scope, IssuancePayload::Evidence, 1, &[0]) .await .unwrap(); - sqlx::query("UPDATE seal_evidence_parts SET protected=? WHERE part=1") + sqlx::query("UPDATE artifact_evidence_parts SET protected=? WHERE part=1") .bind(protected) .execute(&mut database) .await @@ -671,12 +672,12 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ "part fault {fault}" ); } - sqlx::query("DELETE FROM seal_evidence_parts") + sqlx::query("DELETE FROM artifact_evidence_parts") .execute(&mut database) .await .unwrap(); for (part, protected) in &parts { - sqlx::query("INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,?,?)").bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).bind(part).bind(protected).execute(&mut database).await.unwrap(); + sqlx::query("INSERT INTO artifact_evidence_parts(workspace,operation_id,artifact_key,part,protected) VALUES(?,?,?,?,?)").bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind(part).bind(protected).execute(&mut database).await.unwrap(); } let (_, protected) = evidence_store::read(&mut database, &issued.attempt, &crypto) .await @@ -690,25 +691,27 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ for fault in 0..4 { match fault { 0 => { - sqlx::query("UPDATE seal_evidence SET transaction_id=zeroblob(32)") + sqlx::query("UPDATE artifact_evidence SET transaction_id=zeroblob(32)") .execute(&mut database) .await .unwrap(); } 1 => { - sqlx::query("UPDATE seal_evidence_parts SET protected=zeroblob(1) WHERE part=1") - .execute(&mut database) - .await - .unwrap(); + sqlx::query( + "UPDATE artifact_evidence_parts SET protected=zeroblob(1) WHERE part=1", + ) + .execute(&mut database) + .await + .unwrap(); } 2 => { - sqlx::query("DELETE FROM seal_evidence_parts WHERE part=1") + sqlx::query("DELETE FROM artifact_evidence_parts WHERE part=1") .execute(&mut database) .await .unwrap(); } 3 => { - sqlx::query("DELETE FROM seal_evidence") + sqlx::query("DELETE FROM artifact_evidence") .execute(&mut database) .await .unwrap(); @@ -721,21 +724,21 @@ async fn authenticated_evidence_manifests_parts_and_exact_original_observations_ .is_err() ); if fault == 0 { - sqlx::query("UPDATE seal_evidence SET transaction_id=?") + sqlx::query("UPDATE artifact_evidence SET transaction_id=?") .bind(&header.3) .execute(&mut database) .await .unwrap(); } if fault == 1 { - sqlx::query("UPDATE seal_evidence_parts SET protected=? WHERE part=1") + sqlx::query("UPDATE artifact_evidence_parts SET protected=? WHERE part=1") .bind(&parts[0].1) .execute(&mut database) .await .unwrap(); } if fault == 2 { - sqlx::query("INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,1,?)").bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.recipient.as_bytes().as_slice()).bind(&parts[0].1).execute(&mut database).await.unwrap(); + sqlx::query("INSERT INTO artifact_evidence_parts(workspace,operation_id,artifact_key,part,protected) VALUES(?,?,?,1,?)").bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind(&parts[0].1).execute(&mut database).await.unwrap(); } } assert!( @@ -781,7 +784,7 @@ async fn actual_capture_turn_refuses_uncertainty_foreign_scope_and_fabricated_cl UnixSeconds::new(100).unwrap(), ) .unwrap(); - let fabricated = SealEvidence::verify(&fake, issued.evidence.raw_json(), None).unwrap(); + let fabricated = ArtifactEvidence::verify(&fake, issued.evidence.raw_json(), None).unwrap(); let mut uncertain = true; let clock = FixedClock(0); // Any accidental clock consultation must fail. let mut journal = Journal { @@ -913,8 +916,8 @@ async fn installed_descendant_case(mode: u8) { )); let mut database = issued.database().await; for statement in [ - "DELETE FROM seal_evidence_parts", - "DELETE FROM seal_evidence", + "DELETE FROM artifact_evidence_parts", + "DELETE FROM artifact_evidence", "DELETE FROM signing_attempts", ] { if mode == 3 && statement == "DELETE FROM signing_attempts" { diff --git a/crates/storage_sqlite/src/workspace/tests/mod.rs b/crates/storage_sqlite/src/workspace/tests/mod.rs @@ -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=9", + 0 => "PRAGMA user_version=10", 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 { 9 } else { 8 }); + assert_eq!(version, if fault == 0 { 10 } else { 9 }); 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 @@ -5,12 +5,12 @@ use super::{ }; use radroots_domain::{CommandDigest, OperationId, PublicKey}; use radroots_storage::command::{ - AdmissionOutcome, AdmissionRequest, BoundSigningPlan, CapturedSeal, CapturedSigningPlan, - ClaimAttemptOutcome, ClaimAttemptRequest, CommitAttempt, DeliveryAttempt, + AdmissionOutcome, AdmissionRequest, ArtifactEvidence, BoundSigningPlan, CapturedArtifact, + CapturedSigningPlan, ClaimAttemptOutcome, ClaimAttemptRequest, CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryObservation, DeliveryObservationOutcome, EnvelopeCandidate, EvidenceCaptureOutcome, InstallationOutcome, InstallationRequest, OperationError, OperationSnapshot, PlanBindingOutcome, PreparedOperation, - SealEvidence, SigningAttempt, + SigningAttempt, }; use radroots_transport::sink::DeliveryRequestId; use sqlx::{ @@ -91,19 +91,19 @@ enum Job { Capture( Box<AttachmentInput>, AttachmentProof, - Box<SealEvidence>, + Box<ArtifactEvidence>, Reply<EvidenceCaptureOutcome, OperationError>, ), RecoverCapture( Box<AttachmentInput>, AttachmentProof, - Box<SealEvidence>, + Box<ArtifactEvidence>, Reply<EvidenceCaptureOutcome, OperationError>, ), Captured( Box<ClaimAttemptRequest>, AttachmentProof, - Reply<Option<CapturedSeal>, OperationError>, + Reply<Option<CapturedArtifact>, OperationError>, ), BindPlan( Box<WorkspaceBinding>, @@ -758,7 +758,7 @@ impl Handle { &self, input: AttachmentInput, proof: &AttachmentProof, - evidence: &SealEvidence, + evidence: &ArtifactEvidence, ) -> Result<EvidenceCaptureOutcome, OperationError> { let anchor = CommitAttempt::new( evidence.workspace_id(), @@ -783,7 +783,7 @@ impl Handle { &self, input: AttachmentInput, proof: &AttachmentProof, - evidence: &SealEvidence, + evidence: &ArtifactEvidence, ) -> Result<EvidenceCaptureOutcome, OperationError> { let anchor = CommitAttempt::new( evidence.workspace_id(), @@ -807,7 +807,7 @@ impl Handle { &self, request: ClaimAttemptRequest, proof: AttachmentProof, - ) -> Result<Option<CapturedSeal>, OperationError> { + ) -> Result<Option<CapturedArtifact>, OperationError> { let (reply, result) = oneshot::channel(); self.send(Job::Captured(Box::new(request), proof, reply))?; result.await.map_err(|_| OperationError::RecoveryRequired)? @@ -1013,7 +1013,7 @@ pub(super) async fn initialize( .await .map_err(|_| WorkspaceError::StorageFailure)?; } - sqlx::query("PRAGMA user_version=8") + sqlx::query("PRAGMA user_version=9") .execute(&mut *transaction) .await .map_err(|_| WorkspaceError::StorageFailure)?; @@ -1035,11 +1035,63 @@ pub(super) async fn initialize( .fetch_one(&mut *connection) .await .map_err(|_| WorkspaceError::RecoveryRequired)?; - if !matches!(version, 7 | 8) { + if !matches!(version, 7..=9) { return Err(WorkspaceError::RecoveryRequired); } - let catalog_matches: i64 = sqlx::query_scalar("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") - .bind(TABLE).bind(if version==7 {operation::TABLE_V7} else {operation::TABLE}).bind(plan::TABLE).bind(plan::PARTS).bind(attempt::TABLE).bind(attempt::ID_INDEX).bind(attempt::TX_INDEX).bind(evidence::TABLE).bind(evidence::PARTS).bind(evidence::TX_INDEX).bind(operation::INDEX).bind(installation::TABLE).bind(installation::OP_INDEX).bind(installation::TX_INDEX).bind(installation::THREAD_INDEX).bind(installation::WORK).bind(delivery::TABLE).bind(delivery::PARTS).bind(delivery::TX_INDEX).bind(delivery::OBSERVATIONS).fetch_one(&mut *connection).await.map_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 version == 9 { + catalog_sql.replace("seal_evidence", "artifact_evidence") + } else { + catalog_sql.to_owned() + }; + let catalog_matches: i64 = sqlx::query_scalar(sqlx::AssertSqlSafe(catalog_sql)) + .bind(TABLE) + .bind(if version == 7 { + operation::TABLE_V7 + } else { + operation::TABLE + }) + .bind(plan::TABLE) + .bind(plan::PARTS) + .bind(if version == 9 { + attempt::TABLE + } else { + attempt::TABLE_V8 + }) + .bind(attempt::ID_INDEX) + .bind(attempt::TX_INDEX) + .bind(if version == 9 { + evidence::TABLE + } else { + evidence::TABLE_V8 + }) + .bind(if version == 9 { + evidence::PARTS + } else { + evidence::PARTS_V8 + }) + .bind(if version == 9 { + evidence::TX_INDEX + } else { + evidence::TX_INDEX_V8 + }) + .bind(operation::INDEX) + .bind(installation::TABLE) + .bind(installation::OP_INDEX) + .bind(installation::TX_INDEX) + .bind(installation::THREAD_INDEX) + .bind(if version == 9 { + installation::WORK + } else { + installation::WORK_V8 + }) + .bind(delivery::TABLE) + .bind(delivery::PARTS) + .bind(delivery::TX_INDEX) + .bind(delivery::OBSERVATIONS) + .fetch_one(&mut *connection) + .await + .map_err(|_| WorkspaceError::RecoveryRequired)?; if catalog_matches != 1 { return Err(WorkspaceError::RecoveryRequired); } diff --git a/crates/storage_sqlite/tests/support/public_admission.rs b/crates/storage_sqlite/tests/support/public_admission.rs @@ -1,4 +1,4 @@ -//! Actual encrypted T0 only. No signature, installation or delivery is claimed. +//! Actual encrypted public T0/T1/S. Installation and delivery remain separate. use super::*; use radroots_protocol::{listing::PublicSigningPlan, plan::SigningReplay}; use radroots_storage::command::{BoundSigningPlan, ClaimAttemptRequest, PlanBindingOutcome}; @@ -536,6 +536,7 @@ async fn exact_generation_seven_retains_chat_without_rewrite_and_explicitly_refu // Construct the exact old catalog around unchanged encrypted rows. This is // a retained-schema fixture, not a claim that an old binary was executed. let mut db = fixture.database().await; + retain_legacy_issuance_catalog(&mut db).await; let current: String = sqlx::query_scalar("SELECT sql FROM sqlite_schema WHERE name='operations'") .fetch_one(&mut db) @@ -630,3 +631,627 @@ async fn exact_generation_seven_retains_chat_without_rewrite_and_explicitly_refu Err(WorkspaceError::RecoveryRequired) )); } + +mod public_issuance { + use super::*; + use core::{cell::Cell, num::NonZeroU64}; + use nostr::JsonUtil; + use radroots_nostr::{ + key::parse_secret_key, + signing::{LocalSigner, OsNonceSource}, + }; + use radroots_protocol::plan::SigningTarget; + use radroots_signing::{ + issuance::{OutcomeKind, SigningIntent}, + provider::{ParticipantProvider, ProviderCall}, + request::CancellationSignal, + }; + use radroots_storage::command::{ + ArtifactEvidence, ClaimAttemptOutcome, EvidenceCaptureOutcome, SigningAttempt, + }; + thread_local! { static CALLS:Cell<usize>=const {Cell::new(0)}; } + fn signer_clock() -> Result<u64, radroots_signing::Error> { + let first = CALLS.with(|calls| { + let n = calls.get(); + calls.set(n + 1); + n == 0 + }); + if first { + Ok(100_000) + } else { + Err(radroots_signing::Error::new( + radroots_signing::error::Kind::InternalError, + )) + } + } + fn selection( + binding: &WorkspaceBinding, + prepared: &PreparedOperation, + digest: [u8; 32], + ) -> ClaimAttemptRequest { + ClaimAttemptRequest::for_artifact( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + digest, + SigningTarget::PublicEvent, + ) + } + fn claimed(outcome: ClaimAttemptOutcome) -> SigningAttempt { + match outcome { + ClaimAttemptOutcome::Claimed(attempt) => attempt, + _ => panic!("first claim must confirm commit"), + } + } + async fn prepared( + fixture: &Fixture, + store: &NativeWorkspace, + binding: &WorkspaceBinding, + proof: &AttachmentProof, + id: u8, + ) -> (PreparedOperation, [u8; 32]) { + let request = public_request(binding, id, "public signature fixture", "original"); + let mut wire: serde_json::Value = + serde_json::from_slice(request.command().protected_wire()).unwrap(); + wire["input"]["profile"]["product"]["description"] = json!("x".repeat(4096)); + let request = AdmissionRequest::from_protected_wire( + binding.clone(), + &serde_json::to_vec(&wire).unwrap(), + ) + .unwrap(); + let prepared = committed( + store + .admit_command_and_hold(request, copy(proof)) + .await + .unwrap(), + ); + let plan = public_plan( + &prepared, + 100, + &["wss://public-signature.fixture.example/a".into()], + ); + assert!( + plan.event() + .fields() + .tags + .iter() + .any(|tag| tag.iter().any(|field| field.len() > 4096)) + ); + let digest = *plan.digest(); + planned( + store + .bind_signing_intents(binding.clone(), plan.into(), copy(proof)) + .await + .unwrap(), + ); + let _ = fixture; + (prepared, digest) + } + async fn obtain(attempt: &SigningAttempt) -> ArtifactEvidence { + CALLS.with(|calls| calls.set(0)); + // Published synthetic scalar, independent of workstation custody. + let signer = LocalSigner::with_clock( + parse_secret_key("0000000000000000000000000000000000000000000000000000000000000001") + .unwrap(), + signer_clock, + ) + .unwrap() + .with_nonce_source(Arc::new(OsNonceSource)); + let state = signer.provider_state().await.unwrap(); + assert_eq!(state.identity(), key()); + assert_eq!( + state.exact_issuance(), + Some(radroots_signing::recovery::ReplayCapability::NonReplayable) + ); + let cancellation = CancellationSignal::new(); + let intent = SigningIntent::from_plan( + attempt.bound_plan().plan(), + SigningTarget::PublicEvent, + ProviderCall::new(key(), attempt.deadline_unix_ms(), cancellation.clone()), + ) + .unwrap(); + assert_eq!(intent.binding(), attempt.binding()); + assert_eq!(intent.recipient(), None); + let outcome = signer.sign_exact(intent).await; + cancellation.cancel(); + let (_, kind) = outcome.into_parts(); + let OutcomeKind::Obtained(artifact) = kind else { + panic!("qualified local signer must obtain public event") + }; + assert_eq!(artifact.observed_at_unix_ms(), None); + artifact.with_json(|raw| { + let independent = nostr::Event::from_json(raw).unwrap(); + independent.verify().unwrap(); + assert_eq!(independent.kind.as_u16(), 30402); + assert_eq!( + independent.id.as_bytes(), + &attempt.artifact().unwrap().event_id() + ); + ArtifactEvidence::verify(attempt, raw, None).unwrap() + }) + } + fn captured(outcome: EvidenceCaptureOutcome) -> radroots_storage::command::EvidenceReceipt { + match outcome { + EvidenceCaptureOutcome::Committed(receipt) => receipt, + _ => panic!("capture must confirm commit"), + } + } + #[tokio::test] + async fn actual_public_signature_captures_original_bytes_reopens_and_never_reclaims() { + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create_scoped(200, true).await; + let (prepared, digest) = prepared(&fixture, &store, &binding, &proof, 160).await; + let attempt = claimed( + store + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap(), + ); + assert!(matches!( + attempt.seal(), + Err(OperationError::UnsupportedOperation) + )); + assert!(matches!( + store + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap(), + ClaimAttemptOutcome::Retained(_) + )); + let evidence = obtain(&attempt).await; + assert_eq!(evidence.target().recipient(), None); + use radroots_storage::command::protected::issuance::{ClaimRecord, EvidenceManifest}; + let claim_bytes = ClaimRecord::capture(&attempt).unwrap().encode().unwrap(); + let claim_json: serde_json::Value = serde_json::from_slice(&claim_bytes).unwrap(); + assert_eq!(claim_json["version"], 2); + assert_eq!(claim_json["role"], 0); + assert!(claim_json["recipient"].is_null()); + for field in [ + "version", + "role", + "recipient", + "missing_role", + "missing_recipient", + "unknown", + ] { + let mut changed = claim_json.clone(); + match field { + "version" => changed["version"] = json!(1), + "role" => changed["role"] = json!(1), + "recipient" => changed["recipient"] = json!(key()), + "missing_role" => { + changed.as_object_mut().unwrap().remove("role"); + } + "missing_recipient" => { + changed.as_object_mut().unwrap().remove("recipient"); + } + _ => changed["unknown"] = json!(true), + } + let bound = store + .signing_plan( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + assert!( + ClaimRecord::decode( + &serde_json::to_vec(&changed).unwrap(), + bound, + SigningTarget::PublicEvent + ) + .is_err(), + "{field}" + ); + } + let manifest = EvidenceManifest::capture( + &attempt, + &evidence, + radroots_domain::TransactionId::from_bytes([9; 32]), + ) + .unwrap() + .encode() + .unwrap(); + let metadata: serde_json::Value = serde_json::from_slice(&manifest).unwrap(); + assert_eq!(metadata["version"], 2); + assert_eq!(metadata["role"], 0); + assert!(metadata["recipient"].is_null()); + for field in ["version", "role", "recipient"] { + let mut changed = metadata.clone(); + changed[field] = match field { + "recipient" => json!(key()), + _ => json!(1), + }; + assert!( + EvidenceManifest::decode(&serde_json::to_vec(&changed).unwrap(), &attempt).is_err() + ); + } + for (field, value) in [ + ("sig", json!("00".repeat(64))), + ("id", json!("00".repeat(32))), + ("kind", json!(13)), + ("tags", json!([])), + ("content", json!("other")), + ("pubkey", json!("00".repeat(32))), + ("created_at", json!(99)), + ] { + let mut changed: serde_json::Value = serde_json::from_str(evidence.raw_json()).unwrap(); + changed[field] = value; + assert!( + matches!( + ArtifactEvidence::verify(&attempt, &changed.to_string(), None), + Err(OperationError::InvalidEvidence) + ), + "{field}" + ); + } + assert!(ArtifactEvidence::verify(&attempt, &"x".repeat(65537), None).is_err()); + + let raw = evidence.raw_json().to_owned(); + let receipt = captured( + store + .capture_evidence(input.clone(), &proof, &evidence) + .await + .unwrap(), + ); + assert_eq!(receipt.target(), SigningTarget::PublicEvent); + assert_eq!(receipt.observed_at_unix_ms(), None); + let repeated = ArtifactEvidence::verify(&attempt, &raw, NonZeroU64::new(112_000)).unwrap(); + assert_eq!( + captured( + store + .capture_evidence(input.clone(), &proof, &repeated) + .await + .unwrap() + ), + receipt + ); + // The same valid event with another exact JSON encoding is a conflicting + // callback, not permission to replace the original obtained bytes. + let different = + serde_json::to_string_pretty(&serde_json::from_str::<serde_json::Value>(&raw).unwrap()) + .unwrap(); + assert_ne!(raw, different); + let alternate = ArtifactEvidence::verify(&attempt, &different, None).unwrap(); + assert!(matches!( + store + .capture_evidence(input.clone(), &proof, &alternate) + .await, + Err(OperationError::IdempotencyConflict) + )); + let snapshot = store + .operation_snapshot( + binding.clone(), + prepared.identity().operation_id(), + Some(prepared.identity().command_digest()), + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(snapshot.artifacts().len(), 1); + assert_eq!(snapshot.artifacts()[0].target(), SigningTarget::PublicEvent); + assert_eq!(snapshot.artifacts()[0].obtained(), Some(receipt)); + assert!(snapshot.installation().is_none()); + store.close().await.unwrap(); + for name in ["execution_v1.sqlite", "execution_v1.sqlite-wal"] { + if let Ok(bytes) = std::fs::read(fixture.path.join(name)) { + assert!(!bytes.windows(raw.len()).any(|part| part == raw.as_bytes())); + } + } + fixture.clock.now.store(160, Ordering::SeqCst); + let reopened = fixture.reopen(input).await; + let recovered = reopened + .obtained_evidence(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap() + .unwrap(); + assert_eq!(recovered.receipt(), receipt); + assert_eq!(recovered.evidence().raw_json(), raw); + assert_eq!(recovered.attempt().attempt_id(), attempt.attempt_id()); + assert!(matches!( + reopened + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap(), + ClaimAttemptOutcome::Retained(_) + )); + reopened.close().await.unwrap(); + } + #[tokio::test] + async fn public_obtained_capture_survives_revocation_expiry_and_later_clock_failure() { + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create_scoped(200, true).await; + let (prepared, digest) = prepared(&fixture, &store, &binding, &proof, 161).await; + let attempt = claimed( + store + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap(), + ); + let evidence = obtain(&attempt).await; + store.revoke(input.clone(), &proof).await.unwrap(); + fixture.clock.now.store(0, Ordering::SeqCst); + let receipt = captured( + store + .capture_evidence(input.clone(), &proof, &evidence) + .await + .unwrap(), + ); + assert_eq!( + captured( + store + .capture_evidence(input.clone(), &proof, &evidence) + .await + .unwrap() + ), + receipt + ); + assert!( + store + .signing_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .is_err() + ); + store.close().await.unwrap(); + } + #[tokio::test] + async fn public_claim_checks_current_proof_window_and_exact_target_without_dispatch() { + let fixture = Fixture::new(); + let (store, _, proof, binding) = fixture.create_scoped(200, true).await; + let (prepared, digest) = prepared(&fixture, &store, &binding, &proof, 162).await; + assert!(matches!( + store + .claim_attempt( + selection(&binding, &prepared, digest), + AttachmentProof::from_protected_input(&[0; 32]).unwrap() + ) + .await, + Err(OperationError::Workspace(WorkspaceError::Unauthorized)) + )); + assert!(matches!( + store + .claim_attempt( + ClaimAttemptRequest::new( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + digest, + key() + ), + copy(&proof) + ) + .await, + Err(OperationError::UnsupportedOperation) + )); + fixture.clock.now.store(150, Ordering::SeqCst); + assert!(matches!( + store + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await, + Err(OperationError::DeadlineExceeded) + )); + let mut db = fixture.database().await; + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM signing_attempts") + .fetch_one(&mut db) + .await + .unwrap(); + assert_eq!(count, 0); + db.close().await.unwrap(); + store.close().await.unwrap(); + } + #[tokio::test] + async fn lost_public_claim_observer_retains_potential_issuance_without_new_dispatch() { + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create_scoped(200, true).await; + let (prepared, digest) = prepared(&fixture, &store, &binding, &proof, 163).await; + let (arrived, resume) = fixture.clock.arm(1); + let mut pending = store.claim_attempt(selection(&binding, &prepared, digest), copy(&proof)); + assert!(futures::poll!(pending.as_mut()).is_pending()); + reached(arrived).await; + drop(pending); + resume.send(()).unwrap(); + store.close().await.unwrap(); + let reopened = fixture.reopen(input).await; + assert!(matches!( + reopened + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap(), + ClaimAttemptOutcome::Retained(_) + )); + assert!( + reopened + .obtained_evidence(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap() + .is_none() + ); + reopened.close().await.unwrap(); + } + #[tokio::test] + async fn accepted_public_capture_survives_observer_loss_and_drains_on_close() { + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create_scoped(200, true).await; + let (prepared, digest) = prepared(&fixture, &store, &binding, &proof, 164).await; + let attempt = claimed( + store + .claim_attempt(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap(), + ); + let evidence = obtain(&attempt).await; + let mut db = fixture.database().await; + let transaction = db.begin_with("BEGIN IMMEDIATE").await.unwrap(); + let mut pending = store.capture_evidence(input.clone(), &proof, &evidence); + assert!(futures::poll!(pending.as_mut()).is_pending()); + drop(pending); + transaction.rollback().await.unwrap(); + db.close().await.unwrap(); + store.close().await.unwrap(); + let reopened = fixture.reopen(input).await; + let captured = reopened + .obtained_evidence(selection(&binding, &prepared, digest), copy(&proof)) + .await + .unwrap() + .unwrap(); + assert_eq!(captured.evidence().raw_json(), evidence.raw_json()); + reopened.close().await.unwrap(); + } +} + +pub(super) async fn retain_legacy_issuance_catalog(db: &mut SqliteConnection) { + 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(); + let definitions = rows + .into_iter() + .map(|row| { + let name: String = row.get(0); + let ddl: String = row.get(1); + let ddl = ddl + .replace("artifact_evidence", "seal_evidence") + .replace("artifact_key", "recipient") + .replace( + "CHECK(length(recipient)=32 OR (length(recipient)=1 AND hex(recipient)='00'))", + "CHECK(length(recipient)=32)", + ); + (name, ddl) + }) + .collect::<std::collections::BTreeMap<_, _>>(); + for table in [ + "signing_attempts", + "artifact_evidence", + "artifact_evidence_parts", + "chat_publication_work", + ] { + sqlx::query(sqlx::AssertSqlSafe(format!( + "CREATE TEMP TABLE retained_{table} AS SELECT * FROM {table}" + ))) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "chat_publication_work", + "artifact_evidence_parts", + "artifact_evidence", + "signing_attempts", + ] { + sqlx::query(sqlx::AssertSqlSafe(format!("DROP TABLE {table}"))) + .execute(&mut *db) + .await + .unwrap(); + } + for name in [ + "signing_attempts", + "signing_attempt_identity", + "signing_attempt_transaction_identity", + "artifact_evidence", + "artifact_evidence_transaction_identity", + "artifact_evidence_parts", + "chat_publication_work", + ] { + sqlx::query(sqlx::AssertSqlSafe(definitions[name].clone())) + .execute(&mut *db) + .await + .unwrap(); + } + for table in [ + "signing_attempts", + "artifact_evidence", + "artifact_evidence_parts", + "chat_publication_work", + ] { + let legacy = table.replace("artifact_evidence", "seal_evidence"); + 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(); + } + sqlx::query("PRAGMA user_version=8") + .execute(db) + .await + .unwrap(); +} + +#[tokio::test] +async fn exact_generation_eight_preserves_public_t1_and_refuses_public_s_without_rewrite() { + use radroots_protocol::plan::SigningTarget; + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create_scoped(200, true).await; + let prepared = committed( + store + .admit_command_and_hold( + public_request(&binding, 165, "retained generation8 public plan", "first"), + copy(&proof), + ) + .await + .unwrap(), + ); + let plan = public_plan( + &prepared, + 100, + &["wss://public-signature.fixture.example/a".into()], + ); + let wire = plan.protected_wire().to_vec(); + let digest = *plan.digest(); + planned( + store + .bind_signing_intents(binding.clone(), plan.into(), copy(&proof)) + .await + .unwrap(), + ); + store.close().await.unwrap(); + let mut db = fixture.database().await; + retain_legacy_issuance_catalog(&mut db).await; + db.close().await.unwrap(); + let reopened = fixture.reopen(input).await; + let retained = reopened + .signing_plan( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(retained.plan().protected_wire(), wire); + let request = || { + ClaimAttemptRequest::for_artifact( + binding.clone(), + prepared.identity().operation_id(), + prepared.identity().command_digest(), + digest, + SigningTarget::PublicEvent, + ) + }; + assert!( + reopened + .obtained_evidence(request(), copy(&proof)) + .await + .unwrap() + .is_none() + ); + assert!(matches!( + reopened.claim_attempt(request(), copy(&proof)).await, + Err(OperationError::UnsupportedOperation) + )); + reopened.close().await.unwrap(); + let mut db = fixture.database().await; + let version: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut db) + .await + .unwrap(); + assert_eq!(version, 8); + db.close().await.unwrap(); +} diff --git a/crates/storage_sqlite/tests/support/workspace_issuance.rs b/crates/storage_sqlite/tests/support/workspace_issuance.rs @@ -10,8 +10,8 @@ use radroots_signing::{ request::CancellationSignal, }; use radroots_storage::command::{ - CapturedSeal, ClaimAttemptOutcome, ClaimAttemptRequest, EvidenceCaptureOutcome, SealEvidence, - SigningAttempt, + ArtifactEvidence, CapturedArtifact, ClaimAttemptOutcome, ClaimAttemptRequest, + EvidenceCaptureOutcome, SigningAttempt, }; thread_local! {static CALLS:Cell<usize>=const {Cell::new(0)};static MISSING:Cell<bool>=const {Cell::new(false)};} fn signer_clock() -> Result<u64, radroots_signing::Error> { @@ -89,7 +89,7 @@ async fn prepare( let _ = fixture; (prepared, digest, recipients) } -async fn obtain(attempt: &SigningAttempt, missing: bool) -> SealEvidence { +async fn obtain(attempt: &SigningAttempt, missing: bool) -> ArtifactEvidence { CALLS.with(|calls| calls.set(0)); MISSING.with(|value| value.set(missing)); // Published synthetic key in a qualified local provider, isolated from all host custody. @@ -122,7 +122,7 @@ async fn obtain(attempt: &SigningAttempt, missing: bool) -> SealEvidence { }; assert_eq!(artifact.observed_at_unix_ms().is_none(), missing); artifact.with_json(|raw| { - SealEvidence::verify(attempt, raw, artifact.observed_at_unix_ms()).unwrap() + ArtifactEvidence::verify(attempt, raw, artifact.observed_at_unix_ms()).unwrap() }) } fn captured(outcome: EvidenceCaptureOutcome) -> radroots_storage::command::EvidenceReceipt { @@ -165,7 +165,7 @@ async fn real_exact_peer_and_self_signatures_capture_reopen_and_never_reclaim_or .await .unwrap(); assert!(matches!(duplicate, ClaimAttemptOutcome::Retained(_))); - let repeated = SealEvidence::verify(&first, &raw, NonZeroU64::new(111_000)).unwrap(); + let repeated = ArtifactEvidence::verify(&first, &raw, NonZeroU64::new(111_000)).unwrap(); assert_eq!( captured( store @@ -190,7 +190,7 @@ async fn real_exact_peer_and_self_signatures_capture_reopen_and_never_reclaim_or .unwrap() .unwrap(); assert_eq!(original.attempt_id(), id); - let recovered: CapturedSeal = reopened + let recovered: CapturedArtifact = reopened .obtained_evidence( selection(&binding, &prepared, digest, recipient), copy(&proof), @@ -298,7 +298,7 @@ async fn one_recipient_obtained_does_not_invent_the_other_and_failed_capture_kee .unwrap(), ); let mut database = fixture.database().await; - sqlx::raw_sql("CREATE TRIGGER refuse_evidence BEFORE INSERT ON seal_evidence_parts WHEN NEW.part=2 BEGIN SELECT RAISE(ABORT,'synthetic capture failure'); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TRIGGER refuse_evidence BEFORE INSERT ON artifact_evidence_parts WHEN NEW.part=2 BEGIN SELECT RAISE(ABORT,'synthetic capture failure'); END").execute(&mut database).await.unwrap(); assert!(matches!( store .capture_evidence(input.clone(), &proof, &evidence) @@ -306,7 +306,7 @@ async fn one_recipient_obtained_does_not_invent_the_other_and_failed_capture_kee Err(OperationError::StorageFailure) )); assert_eq!(evidence.raw_json(), raw); - let count: i64 = sqlx::query_scalar("SELECT count(*) FROM seal_evidence") + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM artifact_evidence") .fetch_one(&mut database) .await .unwrap(); @@ -388,13 +388,13 @@ async fn verification_refuses_wrong_field_signature_and_binding_before_capture() changed[field] = value; assert!( matches!( - SealEvidence::verify(&first, &changed.to_string(), None), + ArtifactEvidence::verify(&first, &changed.to_string(), None), Err(OperationError::InvalidEvidence) ), "{field}" ); } - assert!(SealEvidence::verify(&first, &"x".repeat(65537), None).is_err()); + assert!(ArtifactEvidence::verify(&first, &"x".repeat(65537), None).is_err()); store.close().await.unwrap(); } @@ -578,7 +578,7 @@ async fn uncertain_capture_keeps_original_bytes_until_safe_reopen_and_exact_retr let evidence = obtain(&first, true).await; let raw = evidence.raw_json().to_owned(); let mut database = fixture.database().await; - sqlx::raw_sql("CREATE TRIGGER capture_unknown BEFORE INSERT ON seal_evidence_parts WHEN NEW.part=2 BEGIN SELECT RAISE(ROLLBACK,'synthetic unknown capture'); END").execute(&mut database).await.unwrap(); + sqlx::raw_sql("CREATE TRIGGER capture_unknown BEFORE INSERT ON artifact_evidence_parts WHEN NEW.part=2 BEGIN SELECT RAISE(ROLLBACK,'synthetic unknown capture'); END").execute(&mut database).await.unwrap(); database.close().await.unwrap(); let outcome = store .capture_evidence(input.clone(), &proof, &evidence) @@ -821,3 +821,121 @@ async fn known_claim_insert_rollback_leaves_no_invocation_and_allows_one_new_cla database.close().await.unwrap(); store.close().await.unwrap(); } + +#[tokio::test] +async fn exact_legacy_private_claim_evidence_bytes_recover_and_continue_without_catalog_rewrite() { + for version in [7, 8] { + let fixture = Fixture::new(); + let (store, input, proof, binding) = fixture.create().await; + let (prepared, digest, recipients) = + prepare(&fixture, &store, &binding, &proof, 166, false).await; + let first = claim( + store + .claim_attempt( + selection(&binding, &prepared, digest, recipients[0]), + copy(&proof), + ) + .await + .unwrap(), + ); + let original_claim = + radroots_storage::command::protected::issuance::ClaimRecord::capture(&first) + .unwrap() + .encode() + .unwrap(); + let claim_json: serde_json::Value = serde_json::from_slice(&original_claim).unwrap(); + assert_eq!(claim_json["version"], 1); + assert_eq!(claim_json["recipient"], json!(recipients[0])); + assert!(claim_json.get("role").is_none()); + let evidence = obtain(&first, false).await; + let receipt = captured( + store + .capture_evidence(input.clone(), &proof, &evidence) + .await + .unwrap(), + ); + let raw = evidence.raw_json().to_owned(); + store.close().await.unwrap(); + let mut db = fixture.database().await; + super::super::public_admission::retain_legacy_issuance_catalog(&mut db).await; + if version == 7 { + let ddl: String = + sqlx::query_scalar("SELECT sql FROM sqlite_schema WHERE name='operations'") + .fetch_one(&mut db) + .await + .unwrap(); + let index: String = sqlx::query_scalar( + "SELECT sql FROM sqlite_schema WHERE name='operation_transaction_identity'", + ) + .fetch_one(&mut db) + .await + .unwrap(); + let old = ddl.replace("'inbox.reply','listing.publish'", "'inbox.reply'"); + // Preserve the exact encrypted T0 and the original dependent rows. + sqlx::query("PRAGMA foreign_keys=OFF") + .execute(&mut db) + .await + .unwrap(); + for statement in [ + "CREATE TEMP TABLE retained_operations AS SELECT * FROM operations", + "DROP TABLE operations", + &old, + &index, + "INSERT INTO operations SELECT * FROM retained_operations", + "DROP TABLE retained_operations", + "PRAGMA user_version=7", + ] { + sqlx::query(sqlx::AssertSqlSafe(statement.to_owned())) + .execute(&mut db) + .await + .unwrap(); + } + } + db.close().await.unwrap(); + let reopened = fixture.reopen(input.clone()).await; + let recovered = reopened + .obtained_evidence( + selection(&binding, &prepared, digest, recipients[0]), + copy(&proof), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(recovered.receipt(), receipt); + assert_eq!(recovered.evidence().raw_json(), raw); + assert!(matches!( + reopened + .claim_attempt( + selection(&binding, &prepared, digest, recipients[0]), + copy(&proof) + ) + .await + .unwrap(), + ClaimAttemptOutcome::Retained(_) + )); + let second = claim( + reopened + .claim_attempt( + selection(&binding, &prepared, digest, recipients[1]), + copy(&proof), + ) + .await + .unwrap(), + ); + let second_evidence = obtain(&second, false).await; + captured( + reopened + .capture_evidence(input, &proof, &second_evidence) + .await + .unwrap(), + ); + reopened.close().await.unwrap(); + let mut db = fixture.database().await; + let actual: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut db) + .await + .unwrap(); + assert_eq!(actual, version); + db.close().await.unwrap(); + } +} diff --git a/crates/storage_sqlite/tests/workspace_admission.rs b/crates/storage_sqlite/tests/workspace_admission.rs @@ -789,7 +789,7 @@ async fn predecessor_grant_only_schema_is_preserved_for_explicit_cutover() { store.close().await.unwrap(); let mut database = fixture.database().await; sqlx::raw_sql( - "DROP TABLE chat_publication_work; DROP TABLE chat_messages; DROP TABLE seal_evidence_parts; DROP TABLE seal_evidence; DROP TABLE signing_attempts; DROP TABLE signing_plan_parts; DROP TABLE signing_plans; DROP INDEX operation_transaction_identity; DROP TABLE operations; PRAGMA user_version=1", + "DROP TABLE chat_publication_work; DROP TABLE chat_messages; DROP TABLE artifact_evidence_parts; DROP TABLE artifact_evidence; DROP TABLE signing_attempts; DROP TABLE signing_plan_parts; DROP TABLE signing_plans; DROP INDEX operation_transaction_identity; DROP TABLE operations; PRAGMA user_version=1", ) .execute(&mut database) .await