commit 241a0257a36be4c47d37cdb7562428b3d3354468 parent 3821b72e5d90bd0c9ab57479ff1b06322833aa10 Author: triesap <tyson@radroots.org> Date: Tue, 27 Oct 2026 02:02:49 +0000 execution: own original acceptance dispatch and refusal capture - Consume native issuer calls and remove public intent extraction. - Retain original refusal material and resource leases through failed capture. - Project authenticated original facts independently of later signatures. - Verify lost callers, uncertain commits, close retry and supported boundaries. Diffstat:
23 files changed, 1016 insertions(+), 112 deletions(-)
diff --git a/contracts/api_baselines/radroots.txt b/contracts/api_baselines/radroots.txt @@ -159,6 +159,7 @@ pub mod radroots::orders pub use radroots::orders::AcceptOrderInput pub use radroots::orders::AcceptanceRecipient pub use radroots::orders::AcceptanceStatus +pub use radroots::orders::AcceptanceUnissuedReceipt pub use radroots::orders::InstalledAcceptance pub struct radroots::orders::Orders<'a> impl<'a> radroots::orders::Orders<'a> diff --git a/contracts/api_baselines/radroots_execution.txt b/contracts/api_baselines/radroots_execution.txt @@ -26,12 +26,20 @@ pub enum radroots_execution::session::commerce::AcceptanceClaimOutcome pub radroots_execution::session::commerce::AcceptanceClaimOutcome::Existing(radroots_execution::session::commerce::AcceptanceClaim) pub radroots_execution::session::commerce::AcceptanceClaimOutcome::Fresh(alloc::boxed::Box<dyn radroots_execution::session::commerce::AcceptanceDispatch>) pub radroots_execution::session::commerce::AcceptanceClaimOutcome::Unknown(radroots_storage::command::CommitAttempt) +pub enum radroots_execution::session::commerce::AcceptanceDispatchOutcome +pub radroots_execution::session::commerce::AcceptanceDispatchOutcome::Obtained(radroots_execution::session::commerce::AcceptanceClaim, radroots_signing::issuance::SignedArtifact) +pub radroots_execution::session::commerce::AcceptanceDispatchOutcome::Rejected(radroots_execution::session::commerce::AcceptanceClaim, radroots_signing::issuance::RejectedArtifact) +pub radroots_execution::session::commerce::AcceptanceDispatchOutcome::Unissued(alloc::boxed::Box<dyn radroots_execution::session::commerce::AcceptanceUnissued>) +pub radroots_execution::session::commerce::AcceptanceDispatchOutcome::Unknown(radroots_execution::session::commerce::AcceptanceClaim, radroots_signing::provider::ProviderError) pub enum radroots_execution::session::commerce::AcceptanceInstallationOutcome pub radroots_execution::session::commerce::AcceptanceInstallationOutcome::Installed(alloc::boxed::Box<radroots_execution::session::commerce::InstalledAcceptance>) pub radroots_execution::session::commerce::AcceptanceInstallationOutcome::Unknown(radroots_storage::command::CommitAttempt) pub enum radroots_execution::session::commerce::AcceptancePlanOutcome pub radroots_execution::session::commerce::AcceptancePlanOutcome::Bound(radroots_storage::command::CommitAttempt) pub radroots_execution::session::commerce::AcceptancePlanOutcome::Unknown(radroots_storage::command::CommitAttempt) +pub enum radroots_execution::session::commerce::AcceptanceUnissuedOutcome +pub radroots_execution::session::commerce::AcceptanceUnissuedOutcome::Committed(alloc::boxed::Box<radroots_execution::session::commerce::AcceptanceUnissuedReceipt>) +pub radroots_execution::session::commerce::AcceptanceUnissuedOutcome::Unknown(radroots_storage::command::CommitAttempt) pub struct radroots_execution::session::commerce::AcceptanceClaim pub radroots_execution::session::commerce::AcceptanceClaim::binding: radroots_protocol::intent::IntentBinding pub radroots_execution::session::commerce::AcceptanceClaim::id: radroots_domain::identifier::SigningAttemptId @@ -40,6 +48,7 @@ pub fn radroots_execution::session::commerce::AcceptanceClaim::fmt(&self, &mut c pub struct radroots_execution::session::commerce::AcceptanceRecipient pub radroots_execution::session::commerce::AcceptanceRecipient::claim: core::option::Option<radroots_execution::session::commerce::AcceptanceClaim> pub radroots_execution::session::commerce::AcceptanceRecipient::evidence: core::option::Option<radroots_storage::inventory::evidence::StockEvidenceReceipt> +pub radroots_execution::session::commerce::AcceptanceRecipient::original_unissued: core::option::Option<radroots_execution::session::commerce::AcceptanceUnissuedReceipt> pub radroots_execution::session::commerce::AcceptanceRecipient::recipient: radroots_identity::key::PublicKey pub struct radroots_execution::session::commerce::AcceptanceSelection pub radroots_execution::session::commerce::AcceptanceSelection::binding: radroots_storage::workspace::WorkspaceBinding @@ -57,6 +66,12 @@ pub const fn radroots_execution::session::commerce::AcceptanceStatus::recipients pub const fn radroots_execution::session::commerce::AcceptanceStatus::record_id(&self) -> radroots_domain::identifier::RecordId impl core::fmt::Debug for radroots_execution::session::commerce::AcceptanceStatus pub fn radroots_execution::session::commerce::AcceptanceStatus::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_execution::session::commerce::AcceptanceUnissuedReceipt +pub radroots_execution::session::commerce::AcceptanceUnissuedReceipt::attempt: radroots_storage::command::CommitAttempt +pub radroots_execution::session::commerce::AcceptanceUnissuedReceipt::checkpoint: radroots_storage::inventory::InventoryCheckpointRef +pub radroots_execution::session::commerce::AcceptanceUnissuedReceipt::claim: radroots_domain::identifier::SigningAttemptId +pub radroots_execution::session::commerce::AcceptanceUnissuedReceipt::reason: radroots_signing::provider::ProviderError +pub radroots_execution::session::commerce::AcceptanceUnissuedReceipt::recipient: radroots_identity::key::PublicKey pub struct radroots_execution::session::commerce::InstalledAcceptance pub radroots_execution::session::commerce::InstalledAcceptance::attempt: radroots_storage::command::CommitAttempt pub radroots_execution::session::commerce::InstalledAcceptance::checkpoint: radroots_storage::inventory::InventoryCheckpointRef @@ -65,7 +80,8 @@ pub radroots_execution::session::commerce::InstalledAcceptance::record: radroots impl core::fmt::Debug for radroots_execution::session::commerce::InstalledAcceptance pub fn radroots_execution::session::commerce::InstalledAcceptance::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub trait radroots_execution::session::commerce::AcceptanceDispatch: radroots_execution::session::HostBound -pub fn radroots_execution::session::commerce::AcceptanceDispatch::into_intent(alloc::boxed::Box<Self>, radroots_signing::request::CancellationSignal) -> core::result::Result<(radroots_signing::issuance::SigningIntent, radroots_execution::session::commerce::AcceptanceClaim), radroots_storage::command::OperationError> +pub fn radroots_execution::session::commerce::AcceptanceDispatch::claim(&self) -> radroots_execution::session::commerce::AcceptanceClaim +pub fn radroots_execution::session::commerce::AcceptanceDispatch::dispatch<'a>(alloc::boxed::Box<Self>, &'a dyn radroots_signing::issuance::ExactIssuer, radroots_signing::request::CancellationSignal) -> radroots_execution::session::HostFuture<'a, core::result::Result<radroots_execution::session::commerce::AcceptanceDispatchOutcome, radroots_storage::command::OperationError>> pub trait radroots_execution::session::commerce::AcceptanceSnapshot: radroots_execution::session::HostBound pub fn radroots_execution::session::commerce::AcceptanceSnapshot::aborted(&self) -> bool pub fn radroots_execution::session::commerce::AcceptanceSnapshot::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef @@ -79,6 +95,11 @@ pub fn radroots_execution::session::commerce::AcceptanceStore::claim<'a>(&'a sel pub fn radroots_execution::session::commerce::AcceptanceStore::exact_replay<'a>(&'a self, radroots_execution::session::commerce::AcceptanceSelection, radroots_identity::key::PublicKey, radroots_signing::provider::ProviderCall, &'a radroots_storage::workspace::AttachmentProof) -> radroots_execution::session::HostFuture<'a, core::result::Result<(radroots_signing::issuance::exact_recovery::ExactRecoveryRequest, radroots_execution::session::commerce::AcceptanceClaim), radroots_storage::command::OperationError>> pub fn radroots_execution::session::commerce::AcceptanceStore::install<'a>(&'a self, radroots_execution::session::commerce::AcceptanceSelection, &'a radroots_storage::workspace::AttachmentProof) -> radroots_execution::session::HostFuture<'a, core::result::Result<radroots_execution::session::commerce::AcceptanceInstallationOutcome, radroots_storage::command::OperationError>> pub fn radroots_execution::session::commerce::AcceptanceStore::snapshot<'a>(&'a self, radroots_execution::session::commerce::AcceptanceSelection, &'a radroots_storage::workspace::AttachmentProof) -> radroots_execution::session::HostFuture<'a, core::result::Result<alloc::boxed::Box<dyn radroots_execution::session::commerce::AcceptanceSnapshot>, radroots_storage::command::OperationError>> +pub trait radroots_execution::session::commerce::AcceptanceUnissued: radroots_execution::session::HostBound +pub fn radroots_execution::session::commerce::AcceptanceUnissued::capture(&self) -> radroots_execution::session::HostFuture<'_, core::result::Result<radroots_execution::session::commerce::AcceptanceUnissuedOutcome, radroots_storage::command::OperationError>> +pub fn radroots_execution::session::commerce::AcceptanceUnissued::claim(&self) -> radroots_execution::session::commerce::AcceptanceClaim +pub fn radroots_execution::session::commerce::AcceptanceUnissued::reason(&self) -> radroots_signing::provider::ProviderError +pub fn radroots_execution::session::commerce::AcceptanceUnissued::reconcile(&self) -> radroots_execution::session::HostFuture<'_, core::result::Result<radroots_execution::session::commerce::AcceptanceUnissuedOutcome, radroots_storage::command::OperationError>> pub mod radroots_execution::session::tasks pub trait radroots_execution::session::tasks::TaskHost: radroots_execution::session::HostBound pub fn radroots_execution::session::tasks::TaskHost::submit(&self, radroots_execution::session::HostFuture<'static, ()>) -> radroots_execution::Result<()> diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -410,6 +410,7 @@ pub radroots_storage_sqlite::workspace::StockSigningPlanOutcome::Unknown(radroot pub enum radroots_storage_sqlite::workspace::StockSigningProgress pub radroots_storage_sqlite::workspace::StockSigningProgress::Bound pub radroots_storage_sqlite::workspace::StockSigningProgress::Obtained +pub radroots_storage_sqlite::workspace::StockSigningProgress::OriginalUnissued pub radroots_storage_sqlite::workspace::StockSigningProgress::Unbound pub radroots_storage_sqlite::workspace::StockSigningProgress::Unknown pub enum radroots_storage_sqlite::workspace::StockSourceOutcome @@ -570,7 +571,6 @@ pub struct radroots_storage_sqlite::workspace::StockDispatchPermit impl radroots_storage_sqlite::workspace::StockDispatchPermit pub fn radroots_storage_sqlite::workspace::StockDispatchPermit::dispatch(self, &dyn radroots_signing::issuance::ExactIssuer, radroots_signing::request::CancellationSignal) -> radroots_signing::signer::BoxFuture<'_, core::result::Result<radroots_storage_sqlite::workspace::StockDispatchOutcome, radroots_storage::command::OperationError>> impl radroots_storage_sqlite::workspace::StockDispatchPermit -pub fn radroots_storage_sqlite::workspace::StockDispatchPermit::into_signing_intent(self, radroots_signing::request::CancellationSignal) -> core::result::Result<(radroots_signing::issuance::SigningIntent, radroots_storage_sqlite::workspace::StockSigningAttempt), radroots_storage::command::OperationError> pub const fn radroots_storage_sqlite::workspace::StockDispatchPermit::report(&self) -> &radroots_storage_sqlite::workspace::StockSigningAttempt impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockDispatchPermit pub fn radroots_storage_sqlite::workspace::StockDispatchPermit::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -688,6 +688,7 @@ pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::claim(& pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::evidence_count(&self) -> radroots_domain::context::Sequence pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::expected_event_id(&self) -> core::option::Option<[u8; 32]> pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::first_evidence(&self) -> core::option::Option<radroots_storage::inventory::evidence::StockEvidenceReceipt> +pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::original_unissued(&self) -> core::option::Option<radroots_storage_sqlite::workspace::StockUnissuedReceipt> pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::progress(&self) -> radroots_storage_sqlite::workspace::StockSigningProgress pub const fn radroots_storage_sqlite::workspace::StockRecipientSnapshot::recipient(&self) -> radroots_identity::key::PublicKey pub struct radroots_storage_sqlite::workspace::StockRequestSnapshot diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -258,6 +258,13 @@ "generic_peer_installed_before_rejected_self_return": true, "unknown_installation_blocks_delivery": true, "native_first_dispatch_owns_issuer_invocation": true, + "shared_first_dispatch_port": "radroots_execution.session.commerce.AcceptanceDispatch.dispatch", + "shared_unissued_owner": "ClientSession.stock_captures", + "shared_unissued_retained_before_capture": true, + "shared_unissued_drained_before_storage_close": true, + "shared_unissued_failure_blocks_fresh_commands": true, + "public_native_intent_extraction": false, + "coherent_snapshot_preserves_original_unissued": true, "exact_issuer_port": "radroots_signing.issuance.ExactIssuer", "native_failure_boundary": "radroots_ffi.Error", "native_failure_preserves_signer_rejection": true, diff --git a/crates/execution/src/session/commerce.rs b/crates/execution/src/session/commerce.rs @@ -7,7 +7,7 @@ use radroots_domain::{CommandDigest, OperationId, OrderId, PublicKey, RecordId, use radroots_protocol::commerce::CommerceSigningPlan; use radroots_signing::{ commerce::VerifiedCommerceSigningPlan, - issuance::{ExactRecoveryRequest, IntentBinding, SigningIntent}, + issuance::{ExactRecoveryRequest, IntentBinding}, provider::ProviderCall, request::CancellationSignal, }; @@ -57,6 +57,8 @@ pub struct AcceptanceRecipient { pub claim: Option<AcceptanceClaim>, /// First authenticated original encoding, if durably observed. pub evidence: Option<StockEvidenceReceipt>, + /// Authenticated fact about the original invocation, independent of later S. + pub original_unissued: Option<AcceptanceUnissuedReceipt>, } /// Actual initial agreement installation, independent of self-copy and delivery. @@ -94,15 +96,12 @@ pub trait AcceptanceSnapshot: HostBound { fn aborted(&self) -> bool; } -/// Consuming a concrete host's fresh confirmed claim transfers one exact intent. -/// An existing claim/report must never construct an implementation of this port. -pub trait AcceptanceDispatch: HostBound { - /// Consumes the host permit once; creates no signature or recovery guarantee. - fn into_intent( - self: Box<Self>, - cancellation: CancellationSignal, - ) -> Result<(SigningIntent, AcceptanceClaim), OperationError>; -} +#[path = "commerce_dispatch.rs"] +mod dispatch; +pub use self::dispatch::{ + AcceptanceDispatch, AcceptanceDispatchOutcome, AcceptanceUnissued, AcceptanceUnissuedOutcome, + AcceptanceUnissuedReceipt, +}; /// Actual host completion of T1; an unknown commit must be queried, not repeated /// as a new preparation or signature. diff --git a/crates/execution/src/session/commerce_dispatch.rs b/crates/execution/src/session/commerce_dispatch.rs @@ -0,0 +1,70 @@ +//! Owned original dispatch and retained refusal IO, without release authority. +use super::*; +use radroots_signing::{ + issuance::{ExactIssuer, RejectedArtifact, SignedArtifact}, + provider::ProviderError, +}; + +/// The host's newly confirmed single-use claim owns its original issuer call. +/// Existing claim reports and recovery refusals cannot construct this port. +pub trait AcceptanceDispatch: HostBound { + /// Original claim, checked by Core before any invocation. + fn claim(&self) -> AcceptanceClaim; + /// Consumes this permit and invokes the selected issuer once. + fn dispatch<'a>( + self: Box<Self>, + issuer: &'a dyn ExactIssuer, + cancellation: CancellationSignal, + ) -> HostFuture<'a, Result<AcceptanceDispatchOutcome, OperationError>>; +} + +/// Original invocation facts; none claims durable capture or installation. +pub enum AcceptanceDispatchOutcome { + /// Exact signed material, which must remain owned through persistence. + Obtained(AcceptanceClaim, SignedArtifact), + /// Owned original refusal; capture has not yet been confirmed. + Unissued(Box<dyn AcceptanceUnissued>), + /// Original invocation remains uncertain; keep its stock claim. + Unknown(AcceptanceClaim, ProviderError), + /// Bounded diagnostic from a rejected callback, never nonissuance proof. + Rejected(AcceptanceClaim, RejectedArtifact), +} + +/// Authenticated original-invocation fact reported by the concrete store. +/// Public report data grants no dispatch, abort, release or capture authority. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct AcceptanceUnissuedReceipt { + /// Actual confirmed capture transaction and original operation identity. + pub attempt: CommitAttempt, + /// Original protected signing claim. + pub claim: radroots_domain::SigningAttemptId, + /// Original exact recipient. + pub recipient: radroots_domain::PublicKey, + /// Original invocation's reported refusal. + pub reason: ProviderError, + /// Authenticated capture checkpoint, without allocation authority. + pub checkpoint: radroots_storage::inventory::InventoryCheckpointRef, +} + +/// Actual durable completion, kept distinct from original signer observation. +pub enum AcceptanceUnissuedOutcome { + /// Original fact was durably retained with a confirmed transaction. + Committed(Box<AcceptanceUnissuedReceipt>), + /// Actual capture transaction has uncertain completion. + Unknown(CommitAttempt), +} + +/// Owns the target's original invocation observation and retained capture proof. +/// Implementations must originate in that host's consumed fresh dispatch and +/// preserve the original material across failed writes and same-owner recovery. +/// Implementing this port does not qualify an arbitrary issuer's honesty. +pub trait AcceptanceUnissued: HostBound { + /// Original claim, never permission to invoke again. + fn claim(&self) -> AcceptanceClaim; + /// Original invocation's independently retained refusal reason. + fn reason(&self) -> ProviderError; + /// Captures borrowed original proof without fresh signing or permission. + fn capture(&self) -> HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>>; + /// Reconciles original material on its retained target owner. + fn reconcile(&self) -> HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>>; +} diff --git a/crates/execution/src/session/commerce_run.rs b/crates/execution/src/session/commerce_run.rs @@ -15,7 +15,7 @@ use radroots_protocol::{ intent::SigningReplay, }; use radroots_signing::{ - issuance::{ExactRecoveryCapability, ExactRecoveryKind, OutcomeKind, SignedArtifact}, + issuance::{ExactRecoveryCapability, ExactRecoveryKind, SignedArtifact, SigningIntent}, provider::PrivateText, recovery::ReplayCapability, }; @@ -51,7 +51,7 @@ pub(crate) fn observe( .map_err(|_| OperationError::RecoveryRequired)?; } else if recipients .iter() - .any(|v| v.claim.is_some() || v.evidence.is_some()) + .any(|v| v.claim.is_some() || v.evidence.is_some() || v.original_unissued.is_some()) { return Err(OperationError::RecoveryRequired); } @@ -82,11 +82,22 @@ pub(crate) fn observe( return Err(OperationError::RecoveryRequired); } } + for recipient in &recipients { + if let Some(value) = recipient.original_unissued + && (!same(value.attempt, selection) + || value.attempt.transaction_id().is_none() + || value.recipient != recipient.recipient + || recipient.claim.is_none_or(|v| v.id != value.claim) + || value.checkpoint.authority() != selection.minimum.authority()) + { + return Err(OperationError::RecoveryRequired); + } + } let installation = snapshot.installation(); if snapshot.aborted() && recipients .iter() - .any(|v| v.claim.is_some() || v.evidence.is_some()) + .any(|v| v.claim.is_some() || v.evidence.is_some() || v.original_unissued.is_some()) { return Err(OperationError::RecoveryRequired); } @@ -261,83 +272,125 @@ impl CommandRuntime { .map_err(|_| fail(OperationError::Unauthorized))?; let capture_proof = copy(proof).map_err(fail)?; let capture_selection = selection.clone(); - let obtained: Option<(SignedArtifact, AcceptanceClaim)> = - if let Some(claim) = facts.claim { - if !matches!(&mode, RunMode::Resume) - || plan.replay() != SigningReplay::LocalReplaySafe - { - None - } else { - let (request, report) = store - .exact_replay( - selection.clone(), - recipient, - call(original).map_err(fail)?, - proof, - ) - .await - .map_err(fail)?; - if report != claim || request.original().binding() != claim.binding { + let obtained: Option<(SignedArtifact, AcceptanceClaim)> = if let Some(claim) = + facts.claim + { + if !matches!(&mode, RunMode::Resume) + || plan.replay() != SigningReplay::LocalReplaySafe + { + None + } else { + let (request, report) = store + .exact_replay( + selection.clone(), + recipient, + call(original).map_err(fail)?, + proof, + ) + .await + .map_err(fail)?; + if report != claim || request.original().binding() != claim.binding { + return Err(fail(OperationError::RecoveryRequired)); + } + self.ensure_ready()?; + match signer.recover_exact(request).await.into_parts().1 { + ExactRecoveryKind::Obtained(artifact) => Some((artifact, report)), + ExactRecoveryKind::Rejected(rejected) => { + return Err(crate::ExecutionFailure::rejected( + selection.operation, + rejected, + )); + } + _ => None, + } + } + } else { + if self.io.now().map_err(fail)? >= original.first_issue_deadline() { + continue; + } + match store + .claim(selection.clone(), recipient, proof) + .await + .map_err(fail)? + { + AcceptanceClaimOutcome::Fresh(permit) => { + let report = permit.claim(); + let seal = plan + .seals() + .iter() + .find(|v| v.recipient() == recipient) + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + let expected = SigningIntent::from_commerce_seal( + seal, + call(original).map_err(fail)?, + ) + .map_err(|_| fail(OperationError::RecoveryRequired))? + .binding(); + if report.binding != expected { return Err(fail(OperationError::RecoveryRequired)); } self.ensure_ready()?; - match signer.recover_exact(request).await.into_parts().1 { - ExactRecoveryKind::Obtained(artifact) => Some((artifact, report)), - ExactRecoveryKind::Rejected(rejected) => { + resources.stock_captures.ensure_ready().map_err(fail)?; + match permit + .dispatch(signer, CancellationSignal::new()) + .await + .map_err(fail)? + { + AcceptanceDispatchOutcome::Obtained(actual, artifact) => { + if actual != report { + resources.stock_captures.retain_obtained( + crate::session::stock_evidence::ObtainedContext { + selection: capture_selection, + claim: report, + recipient, + store: inventory.clone(), + proof: capture_proof, + lease: resources.lease.clone(), + }, + artifact, + ); + return Err(fail(OperationError::RecoveryRequired)); + } + Some((artifact, report)) + } + AcceptanceDispatchOutcome::Unissued(observation) => { + let pending = resources.stock_captures.retain_unissued( + capture_selection.clone(), + report, + recipient, + observation, + resources.lease.clone(), + ); + if !matches!( + resources.stock_captures.capture_unissued(&pending).await?, + AcceptanceUnissuedOutcome::Committed(_) + ) { + return Err(fail(OperationError::RecoveryRequired)); + } + None + } + AcceptanceDispatchOutcome::Rejected(actual, rejected) + if actual == report => + { return Err(crate::ExecutionFailure::rejected( selection.operation, rejected, )); } - _ => None, - } - } - } else { - if self.io.now().map_err(fail)? >= original.first_issue_deadline() { - continue; - } - match store - .claim(selection.clone(), recipient, proof) - .await - .map_err(fail)? - { - AcceptanceClaimOutcome::Fresh(permit) => { - let (intent, report) = permit - .into_intent(CancellationSignal::new()) - .map_err(fail)?; - let seal = plan - .seals() - .iter() - .find(|v| v.recipient() == recipient) - .ok_or_else(|| fail(OperationError::RecoveryRequired))?; - let expected = SigningIntent::from_commerce_seal( - seal, - call(original).map_err(fail)?, - ) - .map_err(|_| fail(OperationError::RecoveryRequired))? - .binding(); - if intent.binding() != expected || report.binding != expected { - return Err(fail(OperationError::RecoveryRequired)); - } - self.ensure_ready()?; - resources.stock_captures.ensure_ready().map_err(fail)?; - match signer.sign_exact(intent).await.into_parts().1 { - OutcomeKind::Obtained(artifact) => Some((artifact, report)), - OutcomeKind::Rejected(rejected) => { - return Err(crate::ExecutionFailure::rejected( - selection.operation, - rejected, - )); - } - _ => None, + AcceptanceDispatchOutcome::Unknown(actual, _) + if actual == report => + { + None } - } - AcceptanceClaimOutcome::Existing(_) => None, - AcceptanceClaimOutcome::Unknown(_) => { - return Err(fail(OperationError::RecoveryRequired)); + _ => return Err(fail(OperationError::RecoveryRequired)), } } - }; + AcceptanceClaimOutcome::Existing(_) => None, + AcceptanceClaimOutcome::Unknown(_) => { + return Err(fail(OperationError::RecoveryRequired)); + } + } + }; if let Some((artifact, claim)) = obtained { let pending = resources.stock_captures.retain_obtained( crate::session::stock_evidence::ObtainedContext { diff --git a/crates/execution/src/session/stock_evidence.rs b/crates/execution/src/session/stock_evidence.rs @@ -10,6 +10,9 @@ use std::{sync::Mutex, vec::Vec}; #[path = "stock_obtained.rs"] mod obtained; pub(super) use obtained::{ObtainedContext, RetainedObtained}; +#[path = "stock_unissued.rs"] +mod unissued; +pub(super) use unissued::RetainedUnissued; pub(super) struct Pending { store: Shared<dyn InventoryStore>, @@ -22,6 +25,7 @@ pub(super) struct Pending { pub(super) struct Owner { unmapped: Mutex<Vec<Shared<RetainedObtained>>>, pending: Mutex<Vec<Shared<Pending>>>, + unissued: Mutex<Vec<Shared<RetainedUnissued>>>, serial: futures::lock::Mutex<()>, } impl Owner { @@ -36,7 +40,11 @@ impl Owner { .unmapped .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); - if pending.is_empty() && unmapped.is_empty() { + let unissued = self + .unissued + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + if pending.is_empty() && unmapped.is_empty() && unissued.is_empty() { Ok(()) } else { Err(OperationError::RecoveryRequired) @@ -150,6 +158,24 @@ impl Owner { let _serial = self.serial.lock().await; loop { let entry = self + .unissued + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .first() + .cloned(); + let Some(entry) = entry else { break }; + if matches!( + self.append_unissued(&entry, true).await?, + crate::session::commerce::AcceptanceUnissuedOutcome::Unknown(_) + ) { + return Err(Error::capture_pending( + OperationError::RecoveryRequired, + OperationContext::retained(entry.operation()), + )); + } + } + loop { + let entry = self .unmapped .lock() .unwrap_or_else(std::sync::PoisonError::into_inner) diff --git a/crates/execution/src/session/stock_obtained_tests.rs b/crates/execution/src/session/stock_obtained_tests.rs @@ -26,6 +26,9 @@ use radroots_storage::{ }, }; use std::num::NonZeroU64; +#[path = "stock_unissued_tests.rs"] +mod unissued; + struct NoIo; impl WorkspaceStore for NoIo { fn authenticate( @@ -76,8 +79,11 @@ impl InventoryStore for NoIo { panic!("unexpected IO") } } -#[test] -fn mapping_refusal_keeps_verified_artifact_credentials_and_lease_before_any_storage_request() { +fn fixture() -> ( + ObtainedContext, + radroots_signing::issuance::SignedArtifact, + std::sync::Weak<()>, +) { let command = CapturedOrderAcceptance::parse(include_bytes!( "../../tests/fixtures/commerce_verification/command_wire.json" )) @@ -168,9 +174,15 @@ fn mapping_refusal_keeps_verified_artifact_credentials_and_lease_before_any_stor proof: AttachmentProof::from_protected_input(&[7; 32]).unwrap(), lease: lease.clone(), }; + drop(lease); + (context, artifact, weak) +} +#[test] +fn mapping_refusal_keeps_verified_artifact_credentials_and_lease_before_any_storage_request() { + let (context, artifact, weak) = fixture(); + let wire = include_str!("../../tests/fixtures/commerce_verification/seal_signed.json"); let owner = Owner::default(); let entry = owner.retain_obtained(context, artifact); - drop(lease); assert_eq!( block_on(owner.capture_obtained(&entry)).unwrap_err().code(), crate::Code::Unauthorized diff --git a/crates/execution/src/session/stock_unissued.rs b/crates/execution/src/session/stock_unissued.rs @@ -0,0 +1,118 @@ +//! Retain original invocation material before any fallible capture or await. +use super::*; +use crate::session::commerce::{ + AcceptanceClaim, AcceptanceSelection, AcceptanceUnissued, AcceptanceUnissuedOutcome, + AcceptanceUnissuedReceipt, +}; +use alloc::boxed::Box; +use radroots_domain::PublicKey; + +pub(in crate::session) struct RetainedUnissued { + selection: AcceptanceSelection, + claim: AcceptanceClaim, + recipient: PublicKey, + observation: Box<dyn AcceptanceUnissued>, + receipt: Mutex<Option<AcceptanceUnissuedReceipt>>, + _lease: Shared<dyn HostBound>, +} +impl RetainedUnissued { + pub(super) fn operation(&self) -> radroots_domain::OperationId { + self.selection.operation + } +} +impl Owner { + pub(in crate::session) fn retain_unissued( + &self, + selection: AcceptanceSelection, + claim: AcceptanceClaim, + recipient: PublicKey, + observation: Box<dyn AcceptanceUnissued>, + lease: Shared<dyn HostBound>, + ) -> Shared<RetainedUnissued> { + let entry = Shared::new(RetainedUnissued { + selection, + claim, + recipient, + observation, + receipt: Mutex::new(None), + _lease: lease, + }); + self.unissued + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .push(entry.clone()); + entry + } + pub(in crate::session) async fn capture_unissued( + &self, + entry: &Shared<RetainedUnissued>, + ) -> crate::Result<AcceptanceUnissuedOutcome> { + let _serial = self.serial.lock().await; + self.append_unissued(entry, false).await + } + pub(super) async fn append_unissued( + &self, + entry: &Shared<RetainedUnissued>, + reconciling: bool, + ) -> crate::Result<AcceptanceUnissuedOutcome> { + let error = |reason| { + Error::capture_pending( + reason, + OperationContext::retained(entry.selection.operation), + ) + }; + let committed = *entry + .receipt + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + if let Some(receipt) = committed { + return Ok(AcceptanceUnissuedOutcome::Committed(Box::new(receipt))); + } + // A malformed report must never cause material to leave this owner. + if entry.observation.claim() != entry.claim { + return Err(error(OperationError::RecoveryRequired)); + } + let outcome = if reconciling { + entry.observation.reconcile().await + } else { + entry.observation.capture().await + } + .map_err(error)?; + let attempt = match &outcome { + AcceptanceUnissuedOutcome::Committed(value) => value.attempt, + AcceptanceUnissuedOutcome::Unknown(value) => *value, + }; + if attempt.workspace_id() != entry.selection.binding.input().workspace_id() + || attempt.operation_id() != entry.selection.operation + || attempt.command_digest() != entry.selection.digest + { + return Err(error(OperationError::RecoveryRequired)); + } + if let AcceptanceUnissuedOutcome::Committed(value) = &outcome { + if attempt.transaction_id().is_none() + || value.claim != entry.claim.id + || value.recipient != entry.recipient + || value.reason != entry.observation.reason() + || value.checkpoint.authority() != entry.selection.minimum.authority() + { + return Err(error(OperationError::RecoveryRequired)); + } + *entry + .receipt + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(**value); + let removed = { + let mut pending = self + .unissued + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + pending + .iter() + .position(|v| Shared::ptr_eq(v, entry)) + .map(|i| pending.remove(i)) + }; + drop(removed); + } + Ok(outcome) + } +} diff --git a/crates/execution/src/session/stock_unissued_tests.rs b/crates/execution/src/session/stock_unissued_tests.rs @@ -0,0 +1,152 @@ +//! Coordinator-only hostile-report models; these confer no stock authority. +use super::*; +use crate::session::commerce::{ + AcceptanceUnissued, AcceptanceUnissuedOutcome, AcceptanceUnissuedReceipt, +}; +use alloc::boxed::Box; +use radroots_domain::TransactionId; +use radroots_signing::provider::ProviderError; +use std::sync::atomic::{AtomicUsize, Ordering}; +struct Observation { + claim: AcceptanceClaim, + receipt: AcceptanceUnissuedReceipt, + mode: Shared<AtomicUsize>, +} +impl AcceptanceUnissued for Observation { + fn claim(&self) -> AcceptanceClaim { + let mut claim = self.claim; + if self.mode.load(Ordering::SeqCst) == 9 { + claim.id = SigningAttemptId::from_bytes([0xfa; 32]); + } + claim + } + fn reason(&self) -> ProviderError { + ProviderError::Cancelled + } + fn capture( + &self, + ) -> crate::session::HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> { + Box::pin(async move { + let mode = self.mode.load(Ordering::SeqCst); + let mut receipt = self.receipt; + let a = receipt.attempt; + receipt.attempt = radroots_storage::command::CommitAttempt::new( + if mode == 1 { + WorkspaceId::from_bytes([0xfb; 32]) + } else { + a.workspace_id() + }, + if mode == 2 { + OperationId::from_bytes([0xfb; 32]) + } else { + a.operation_id() + }, + if mode == 3 { + CommandDigest::from_bytes([0xfb; 32]) + } else { + a.command_digest() + }, + if mode == 4 { None } else { a.transaction_id() }, + ); + if mode == 5 { + receipt.claim = SigningAttemptId::from_bytes([0xfb; 32]); + } + if mode == 6 { + receipt.recipient = PublicKey::from_hex( + "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9", + ) + .unwrap(); + } + if mode == 7 { + receipt.reason = ProviderError::DeadlineExceeded; + } + if mode == 8 { + receipt.checkpoint = InventoryCheckpointRef::from_host_metadata( + AuthorityRef::new( + ExecutorId::from_bytes([0xfb; 32]), + Generation::new(1).unwrap(), + ), + Sequence::new(0).unwrap(), + None, + ) + .unwrap(); + } + if mode == 10 { + return Ok(AcceptanceUnissuedOutcome::Unknown(receipt.attempt)); + } + if mode == 11 { + return Err(OperationError::StorageFailure); + } + Ok(AcceptanceUnissuedOutcome::Committed(Box::new(receipt))) + }) + } + fn reconcile( + &self, + ) -> crate::session::HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> { + self.capture() + } +} +#[test] +fn every_mismatched_or_uncertain_host_report_keeps_original_observation_and_lease_until_confirmed() +{ + for mode in 1..=11 { + let (context, _artifact, weak) = fixture(); + let control = Shared::new(AtomicUsize::new(mode)); + let receipt = AcceptanceUnissuedReceipt { + attempt: radroots_storage::command::CommitAttempt::new( + context.selection.binding.input().workspace_id(), + context.selection.operation, + context.selection.digest, + Some(TransactionId::from_bytes([0xaa; 32])), + ), + claim: context.claim.id, + recipient: context.recipient, + reason: ProviderError::Cancelled, + checkpoint: context.selection.minimum, + }; + assert_ne!( + receipt.recipient.to_hex(), + "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9" + ); + let owner = Owner::default(); + let operation = context.selection.operation; + let observation = Box::new(Observation { + claim: context.claim, + receipt, + mode: control.clone(), + }); + let entry = owner.retain_unissued( + context.selection, + context.claim, + context.recipient, + observation, + context.lease, + ); + let result = block_on(owner.capture_unissued(&entry)); + if mode == 10 { + assert!(matches!(result, Ok(AcceptanceUnissuedOutcome::Unknown(_)))); + } else { + let error = result + .err() + .expect("mismatched or failed capture must refuse"); + assert_eq!( + error.code(), + if mode == 11 { + crate::Code::StorageFailure + } else { + crate::Code::RecoveryRequired + } + ); + assert_eq!(error.context().operation_id(), Some(operation)); + assert_eq!(error.context().admission(), crate::Admission::Confirmed); + } + drop(entry); + assert!(weak.upgrade().is_some()); + assert!(owner.ensure_ready().is_err()); + assert_eq!(owner.unissued.lock().unwrap().len(), 1); + control.store(0, Ordering::SeqCst); + block_on(owner.drain()).unwrap(); + assert!(owner.ensure_ready().is_ok()); + assert!(weak.upgrade().is_none()); + } +} diff --git a/crates/radroots/README.md b/crates/radroots/README.md @@ -196,3 +196,12 @@ and resource ownership before disposing callbacks, keys or storage. The concrete qualified store still authenticates the actual protected claim and exact signed bytes; input and receipt metadata grant no authority. This low-level capture surface supplies neither full commerce execution nor original nonissuance proof. + +Original acceptance dispatch is consumed by the selected native host, which owns +its one exact issuer invocation. An original pre-dispatch refusal is retained by +the client before storage capture, survives a lost caller or failed append, and +joins explicit evidence drain and close retry. Coherent recipient status retains +that authenticated original fact separately from any later valid signature. +Recovery refusals never become original observations. These facts do not release +stock or qualify arbitrary adapters; claimed-abort handling and full commerce +accounting remain in implementation. diff --git a/crates/radroots/src/native_commerce.rs b/crates/radroots/src/native_commerce.rs @@ -3,14 +3,15 @@ use radroots_domain::PublicKey; use radroots_execution::session::{ HostFuture, commerce::{ - AcceptanceClaim, AcceptanceClaimOutcome, AcceptanceDispatch, AcceptanceInstallationOutcome, - AcceptancePlanOutcome, AcceptanceRecipient, AcceptanceSelection, AcceptanceSnapshot, - AcceptanceStore, InstalledAcceptance, + AcceptanceClaim, AcceptanceClaimOutcome, AcceptanceDispatch, AcceptanceDispatchOutcome, + AcceptanceInstallationOutcome, AcceptancePlanOutcome, AcceptanceRecipient, + AcceptanceSelection, AcceptanceSnapshot, AcceptanceStore, AcceptanceUnissued, + AcceptanceUnissuedOutcome, AcceptanceUnissuedReceipt, InstalledAcceptance, }, }; use radroots_signing::{ host::Shared, - issuance::{ExactRecoveryRequest, SigningIntent}, + issuance::{ExactIssuer, ExactRecoveryRequest}, provider::ProviderCall, request::CancellationSignal, }; @@ -20,15 +21,76 @@ use radroots_storage::{ workspace::AttachmentProof, }; use radroots_storage_sqlite::workspace::{ - NativeWorkspace, StockClaimOutcome, StockClaimRequest, StockDispatchPermit, - StockInstallationOutcome, StockInstallationReceipt, StockInstallationRequest, - StockOperationSnapshot, StockSigningAttempt, StockSigningPlanOutcome, StockSigningPlanRequest, - StockSnapshotRequest, + NativeWorkspace, StockClaimOutcome, StockClaimRequest, StockDispatchOutcome, + StockDispatchPermit, StockInstallationOutcome, StockInstallationReceipt, + StockInstallationRequest, StockOperationSnapshot, StockSigningAttempt, StockSigningPlanOutcome, + StockSigningPlanRequest, StockSnapshotRequest, StockUnissuedInvocation, StockUnissuedOutcome, + StockUnissuedReceipt, }; pub(crate) struct NativeCommerce(pub(crate) Shared<NativeWorkspace>); struct Snapshot(StockOperationSnapshot); -struct Dispatch(StockDispatchPermit); +struct Dispatch { + permit: StockDispatchPermit, + store: Shared<NativeWorkspace>, + binding: radroots_storage::workspace::WorkspaceBinding, + proof: AttachmentProof, +} +struct Unissued { + observation: StockUnissuedInvocation, + store: Shared<NativeWorkspace>, + binding: radroots_storage::workspace::WorkspaceBinding, + proof: AttachmentProof, +} +fn refusal(value: &StockUnissuedReceipt) -> AcceptanceUnissuedReceipt { + AcceptanceUnissuedReceipt { + attempt: value.attempt(), + claim: value.signing_attempt_id(), + recipient: value.recipient(), + reason: value.reason(), + checkpoint: value.checkpoint(), + } +} +fn refusal_outcome(value: StockUnissuedOutcome) -> AcceptanceUnissuedOutcome { + match value { + StockUnissuedOutcome::Committed(value) => { + AcceptanceUnissuedOutcome::Committed(Box::new(refusal(&value))) + } + StockUnissuedOutcome::Unknown(value) => AcceptanceUnissuedOutcome::Unknown(value), + } +} +impl AcceptanceUnissued for Unissued { + fn claim(&self) -> AcceptanceClaim { + claim(self.observation.attempt()) + } + fn reason(&self) -> radroots_signing::provider::ProviderError { + self.observation.reason() + } + fn capture(&self) -> HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> { + Box::pin(async move { + self.store + .capture_stock_original_unissued( + self.binding.clone(), + &self.observation, + &self.proof, + ) + .await + .map(refusal_outcome) + }) + } + fn reconcile(&self) -> HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> { + Box::pin(async move { + self.store + .reconcile_stock_original_unissued( + self.binding.clone(), + &self.observation, + &self.proof, + ) + .await + .map(refusal_outcome) + }) + } +} fn claim(value: &StockSigningAttempt) -> AcceptanceClaim { AcceptanceClaim { id: value.attempt_id(), @@ -61,6 +123,7 @@ impl AcceptanceSnapshot for Snapshot { binding: c.binding(), }), evidence: v.first_evidence(), + original_unissued: v.original_unissued().as_ref().map(refusal), }) } fn installation(&self) -> Option<InstalledAcceptance> { @@ -71,12 +134,41 @@ impl AcceptanceSnapshot for Snapshot { } } impl AcceptanceDispatch for Dispatch { - fn into_intent( + fn claim(&self) -> AcceptanceClaim { + claim(self.permit.report()) + } + fn dispatch<'a>( self: Box<Self>, + issuer: &'a dyn ExactIssuer, cancel: CancellationSignal, - ) -> Result<(SigningIntent, AcceptanceClaim), OperationError> { - let (intent, report) = self.0.into_signing_intent(cancel)?; - Ok((intent, claim(&report))) + ) -> HostFuture<'a, Result<AcceptanceDispatchOutcome, OperationError>> { + Box::pin(async move { + let Self { + permit, + store, + binding, + proof, + } = *self; + Ok(match permit.dispatch(issuer, cancel).await? { + StockDispatchOutcome::Obtained { attempt, artifact } => { + AcceptanceDispatchOutcome::Obtained(claim(&attempt), artifact) + } + StockDispatchOutcome::Unissued(observation) => { + AcceptanceDispatchOutcome::Unissued(Box::new(Unissued { + observation, + store, + binding, + proof, + })) + } + StockDispatchOutcome::Unknown { attempt, reason } => { + AcceptanceDispatchOutcome::Unknown(claim(&attempt), reason) + } + StockDispatchOutcome::Rejected { attempt, rejection } => { + AcceptanceDispatchOutcome::Rejected(claim(&attempt), rejection) + } + }) + }) } } fn select(value: AcceptanceSelection, recipient: PublicKey) -> StockClaimRequest { @@ -141,13 +233,22 @@ impl AcceptanceStore for NativeCommerce { proof: &'a AttachmentProof, ) -> HostFuture<'a, Result<AcceptanceClaimOutcome, OperationError>> { Box::pin(async move { + // Retain capture material before admission and before the issuer runs. + let binding = value.binding.clone(); + let retained_proof = + proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; match self .0 .claim_stock_signing_attempt(select(value, recipient), proof) .await? { StockClaimOutcome::Fresh(value) => { - Ok(AcceptanceClaimOutcome::Fresh(Box::new(Dispatch(value)))) + Ok(AcceptanceClaimOutcome::Fresh(Box::new(Dispatch { + permit: value, + store: self.0.clone(), + binding, + proof: retained_proof, + }))) } StockClaimOutcome::Existing(value) => { Ok(AcceptanceClaimOutcome::Existing(claim(&value))) diff --git a/crates/radroots/src/native_commerce_tests.rs b/crates/radroots/src/native_commerce_tests.rs @@ -81,6 +81,7 @@ impl WorkspaceClock for Clock { } } struct Control { + pause_refused: AtomicBool, pause_rejected: AtomicBool, tamper_recovery: AtomicBool, tamper_self: AtomicBool, @@ -96,6 +97,7 @@ struct Control { impl Control { fn new() -> Self { Self { + pause_refused: AtomicBool::new(false), pause_rejected: AtomicBool::new(false), tamper_recovery: AtomicBool::new(false), tamper_self: AtomicBool::new(false), @@ -154,6 +156,10 @@ impl ParticipantProvider for Provider { self.control.signs.fetch_add(1, Ordering::SeqCst); let is_self = intent.recipient() == Some(self.inner.public_key()); if is_self && self.control.fail_self.load(Ordering::SeqCst) { + if self.control.pause_refused.swap(false, Ordering::SeqCst) { + self.control.entered.notify_one(); + self.control.release.notified().await; + } return SigningOutcome::not_dispatched(intent.binding(), ProviderError::Cancelled); } let result = self.inner.sign_exact(intent).await; @@ -749,6 +755,9 @@ async fn lost_observer_cannot_discard_actual_peer_artifact_and_close_installs_be reopened.close().await.unwrap(); } +#[path = "native_refusal_tests.rs"] +mod original_refusals; + #[tokio::test] async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_recovery() { let r = Rig::new().await; @@ -766,6 +775,12 @@ async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_ 1 ); assert!(!status.aborted()); + let original_refusal = status + .recipients() + .iter() + .find_map(|v| v.original_unissued) + .expect("actual original refusal must be captured"); + assert_eq!(original_refusal.reason, ProviderError::Cancelled); assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); r.control.fail_self.store(false, Ordering::SeqCst); let (_, _, minimum) = r.minima().await; @@ -779,6 +794,13 @@ async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_ assert!(resumed.recipients().iter().all(|v| v.evidence.is_some())); assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1); + assert_eq!( + resumed + .recipients() + .iter() + .find_map(|v| v.original_unissued), + Some(original_refusal) + ); r.client.close().await.unwrap(); assert!(r.provider.upgrade().is_none()); } diff --git a/crates/radroots/src/native_refusal_tests.rs b/crates/radroots/src/native_refusal_tests.rs @@ -0,0 +1,222 @@ +//! Actual ordinary-session refusal ownership, SQL faults and lost observation. +use super::{ + AcceptOrderInput, AccessPolicy, AllocationSelection, BackendKind, CapturedOrderAcceptance, + KeyVersion, NativeWorkspace, Ordering, ProviderError, Rig, SecretId, SecretMaterial, SecretRef, + StockSnapshotRequest, UnixSeconds, WorkspaceClock, WorkspaceCrypto, +}; +use sqlx::Connection; + +async fn fault(r: &Rig, uncertain: bool) -> sqlx::SqliteConnection { + let path = r._temp.path().join("stock/stock_execution_v1.sqlite"); + let mut connection = sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())) + .await + .unwrap(); + if uncertain { + sqlx::raw_sql("PRAGMA foreign_keys=ON; CREATE TABLE deferred_refusal_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_refusal_fault AFTER INSERT ON stock_original_unissued BEGIN INSERT INTO deferred_refusal_fault VALUES(2); END").execute(&mut connection).await.unwrap(); + } else { + sqlx::query("CREATE TRIGGER controlled_refusal_fault BEFORE INSERT ON stock_original_unissued BEGIN SELECT RAISE(ABORT,'original_refusal_fault'); END").execute(&mut connection).await.unwrap(); + } + connection +} +async fn remove_fault(connection: &mut sqlx::SqliteConnection) { + sqlx::raw_sql( + "DROP TRIGGER controlled_refusal_fault; DROP TABLE IF EXISTS deferred_refusal_fault", + ) + .execute(&mut *connection) + .await + .unwrap(); +} +fn assert_fact(status: &crate::orders::AcceptanceStatus, command: &CapturedOrderAcceptance) { + assert!(status.installation().is_some()); + let value = status + .recipients() + .iter() + .find(|v| v.original_unissued.is_some()) + .unwrap(); + let receipt = value.original_unissued.unwrap(); + assert_eq!(receipt.claim, value.claim.unwrap().id); + assert_eq!( + receipt.attempt.operation_id(), + command.context().operation_id() + ); + assert_eq!(receipt.attempt.command_digest(), command.digest()); + assert!(receipt.attempt.transaction_id().is_some()); + assert_eq!(receipt.reason, ProviderError::Cancelled); + assert!(value.evidence.is_none()); + assert!(!status.aborted()); +} + +#[tokio::test] +async fn actual_refusal_append_failure_is_owned_and_explicit_drain_needs_no_clock_or_reissue() { + let r = Rig::new().await; + r.control.fail_self.store(true, Ordering::SeqCst); + let mut connection = fault(&r, false).await; + let (command, context) = r.captured().await; + let (private, public, minimum) = r.minima().await; + let input = || { + AcceptOrderInput::new( + command.input().request(), + command.input().terms_digest(), + AllocationSelection::automatic(), + ) + }; + let failure = r + .client + .orders(&r.scope) + .accept(context, minimum, private, public, input()) + .await + .unwrap_err(); + assert_eq!(failure.code(), crate::Code::StorageFailure); + assert_eq!(failure.context().admission(), crate::Admission::Confirmed); + assert_eq!( + failure.context().operation_id(), + Some(command.context().operation_id()) + ); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + let context = r + .scope + .command_context( + command.context().operation_id(), + command.context().expected().cloned(), + command.context().approval().cloned(), + UnixSeconds::new(230).unwrap(), + ) + .unwrap(); + let blocked = r + .client + .orders(&r.scope) + .accept(context, minimum, private, public, input()) + .await + .unwrap_err(); + assert_eq!(blocked.code(), crate::Code::RecoveryRequired); + remove_fault(&mut connection).await; + connection.close().await.unwrap(); + r.clock.0.store(u64::MAX, Ordering::SeqCst); + assert!(r.clock.now().is_err()); + r.client.stock(&r.scope).drain_evidence().await.unwrap(); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); + r.clock.0.store(150, Ordering::SeqCst); + let status = r + .client + .orders(&r.scope) + .acceptance_status(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_fact(&status, &command); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); +} + +#[tokio::test] +async fn lost_refusal_waiter_and_failed_close_retain_owner_through_rollback_and_commit_uncertainty() +{ + for uncertain in [false, true] { + let r = Rig::new().await; + r.control.fail_self.store(true, Ordering::SeqCst); + r.control.pause_refused.store(true, Ordering::SeqCst); + let (command, context) = r.captured().await; + let (private, public, minimum) = r.minima().await; + let input = AcceptOrderInput::new( + command.input().request(), + command.input().terms_digest(), + AllocationSelection::automatic(), + ); + let client = r.client.clone(); + let scope = r.scope.clone(); + let observer = tokio::spawn(async move { + client + .orders(&scope) + .accept(context, minimum, private, public, input) + .await + }); + tokio::time::timeout( + std::time::Duration::from_secs(20), + r.control.entered.notified(), + ) + .await + .unwrap(); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + observer.abort(); + assert!(observer.await.unwrap_err().is_cancelled()); + let mut connection = fault(&r, uncertain).await; + r.control.release.notify_one(); + let error = r.client.close().await.unwrap_err(); + assert_eq!( + error.code(), + if uncertain { + crate::Code::RecoveryRequired + } else { + crate::Code::StorageFailure + } + ); + assert_eq!(error.context().admission(), crate::Admission::Confirmed); + assert_eq!( + error.context().operation_id(), + Some(command.context().operation_id()) + ); + assert!(r.provider.upgrade().is_some()); + remove_fault(&mut connection).await; + connection.close().await.unwrap(); + r.clock.0.store(u64::MAX, Ordering::SeqCst); + assert!(r.clock.now().is_err()); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); + r.clock.0.store(150, Ordering::SeqCst); + let crypto = WorkspaceCrypto::new( + r.vault.clone(), + SecretRef::new( + SecretId::parse("workspace-key").unwrap(), + BackendKind::File, + KeyVersion::new(1).unwrap(), + ), + SecretMaterial::from_slice(&[0x41; 32]).unwrap(), + AccessPolicy::standard(), + ) + .unwrap(); + let reopened = NativeWorkspace::open_seller_stock( + &r._temp.path().join("stock"), + r.enrollment.input().clone(), + crypto, + r.clock.clone(), + ) + .await + .unwrap(); + let binding = reopened + .authenticate(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap(); + let snapshot = reopened + .stock_operation_snapshot( + StockSnapshotRequest::new( + binding, + minimum, + command.context().operation_id(), + command.digest(), + ), + r.enrollment.proof(), + ) + .await + .unwrap(); + assert!(snapshot.installation().is_some()); + let facts = snapshot + .recipients() + .iter() + .filter_map(|v| v.original_unissued()) + .collect::<Vec<_>>(); + assert_eq!(facts.len(), 1); + assert_eq!(facts[0].reason(), ProviderError::Cancelled); + assert_eq!( + snapshot + .recipients() + .iter() + .filter(|v| v.first_evidence().is_some()) + .count(), + 1 + ); + assert!(snapshot.aborted().is_none()); + reopened.close().await.unwrap(); + } +} diff --git a/crates/radroots/src/orders.rs b/crates/radroots/src/orders.rs @@ -2,7 +2,7 @@ use crate::{Client, CommandContext, Result, WorkspaceSession}; use radroots_domain::{CommandDigest, OperationId}; pub use radroots_execution::session::commerce::{ - AcceptanceRecipient, AcceptanceStatus, InstalledAcceptance, + AcceptanceRecipient, AcceptanceStatus, AcceptanceUnissuedReceipt, InstalledAcceptance, }; pub use radroots_protocol::command::AcceptOrderInput; use radroots_storage::{ diff --git a/crates/storage_sqlite/src/workspace/stock/issuance/claim.rs b/crates/storage_sqlite/src/workspace/stock/issuance/claim.rs @@ -104,6 +104,13 @@ impl std::fmt::Debug for StockSigningAttempt { /// Single-use confirmed first-dispatch boundary, distinct from actual provider /// capability and destination policy. Those remain caller obligations before /// invoking the signer. An original/recovered claim cannot construct this type. +/// +/// ```compile_fail +/// use radroots_storage_sqlite::workspace::StockDispatchPermit; +/// fn extract(permit: StockDispatchPermit) { +/// let _ = permit.into_signing_intent(radroots_signing::request::CancellationSignal::new()); +/// } +/// ``` pub struct StockDispatchPermit { report: StockSigningAttempt, } @@ -113,7 +120,7 @@ impl StockDispatchPermit { } /// Consumes this first-dispatch permit to expose the unchanged exact intent. /// The returned report anchors later capture; it cannot reissue a permit. - pub fn into_signing_intent( + fn into_intent( self, cancellation: CancellationSignal, ) -> Result<(SigningIntent, StockSigningAttempt), OperationError> { diff --git a/crates/storage_sqlite/src/workspace/stock/issuance/claim/dispatch.rs b/crates/storage_sqlite/src/workspace/stock/issuance/claim/dispatch.rs @@ -71,7 +71,7 @@ impl StockDispatchPermit { cancellation: CancellationSignal, ) -> BoxFuture<'_, Result<StockDispatchOutcome, OperationError>> { Box::pin(async move { - let (intent, attempt) = self.into_signing_intent(cancellation)?; + let (intent, attempt) = self.into_intent(cancellation)?; let binding = attempt.binding(); let (_, kind) = issuer .issue_exact(intent) diff --git a/crates/storage_sqlite/src/workspace/stock/issuance/unissued.rs b/crates/storage_sqlite/src/workspace/stock/issuance/unissued.rs @@ -178,7 +178,13 @@ pub(in crate::workspace::stock) struct Retained { projection: Projection, } impl Retained { - async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> { + pub(in crate::workspace::stock) fn receipt(&self) -> StockUnissuedReceipt { + *self.value + } + pub(in crate::workspace::stock) async fn confirm( + &self, + connection: &mut SqliteConnection, + ) -> Result<(), OperationError> { ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?; ledger::confirm_parts( connection, @@ -280,7 +286,7 @@ pub(in crate::workspace::stock) async fn read_entry( retained.confirm(connection).await?; Ok(Some(retained)) } -async fn lookup( +pub(in crate::workspace::stock) async fn lookup( connection: &mut SqliteConnection, input: &AttachmentInput, crypto: &WorkspaceCrypto, diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/evidence_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/evidence_tests.rs @@ -17,14 +17,18 @@ async fn obtained( let StockClaimOutcome::Fresh(permit) = claim(r, receipt, recipient).await.unwrap() else { panic!("first claim"); }; - let (intent, report) = permit - .into_signing_intent(CancellationSignal::new()) - .unwrap(); let signer = LocalSigner::with_clock(SecretKey::parse(&format!("{:064x}", 3)).unwrap(), || { Ok(150000) }) .unwrap(); - let (_, OutcomeKind::Obtained(signed)) = signer.sign_exact(intent).await.into_parts() else { + let crate::workspace::StockDispatchOutcome::Obtained { + attempt: report, + artifact: signed, + } = permit + .dispatch(&signer, CancellationSignal::new()) + .await + .unwrap() + else { panic!("real signature"); }; (report, signed.with_json(str::to_owned)) diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/snapshot_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/snapshot_tests.rs @@ -44,9 +44,7 @@ async fn original_t0_t1_unknown_and_partial_obtained_states_form_one_coherent_re let StockClaimOutcome::Fresh(permit) = claim(&r, &receipt, recipient).await.unwrap() else { panic!("first claim"); }; - let (intent, report) = permit - .into_signing_intent(CancellationSignal::new()) - .unwrap(); + let report = permit.report(); let unknown = snapshot(&r, &receipt).await; assert_eq!(unknown.recipients()[0].progress(), Progress::Unknown); assert_eq!( @@ -57,7 +55,14 @@ async fn original_t0_t1_unknown_and_partial_obtained_states_form_one_coherent_re Ok(150000) }) .unwrap(); - let (_, OutcomeKind::Obtained(signed)) = signer.sign_exact(intent).await.into_parts() else { + let crate::workspace::StockDispatchOutcome::Obtained { + attempt: report, + artifact: signed, + } = permit + .dispatch(&signer, CancellationSignal::new()) + .await + .unwrap() + else { panic!("actual signing"); }; let raw = signed.with_json(str::to_owned); diff --git a/crates/storage_sqlite/src/workspace/stock/snapshot.rs b/crates/storage_sqlite/src/workspace/stock/snapshot.rs @@ -41,6 +41,7 @@ pub enum StockSigningProgress { Bound, Unknown, Obtained, + OriginalUnissued, } /// Immutable claim identity. This reference cannot construct a dispatch permit. #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -71,6 +72,7 @@ pub struct StockRecipientSnapshot { claim: Option<StockClaimReference>, count: Sequence, first: Option<StockEvidenceReceipt>, + unissued: Option<super::StockUnissuedReceipt>, } impl StockRecipientSnapshot { pub const fn recipient(&self) -> PublicKey { @@ -89,9 +91,15 @@ impl StockRecipientSnapshot { pub const fn first_evidence(&self) -> Option<StockEvidenceReceipt> { self.first } + /// Authenticated original-invocation fact, independent of later S. + pub const fn original_unissued(&self) -> Option<super::StockUnissuedReceipt> { + self.unissued + } pub const fn progress(&self) -> StockSigningProgress { if self.first.is_some() { StockSigningProgress::Obtained + } else if self.unissued.is_some() { + StockSigningProgress::OriginalUnissued } else if self.claim.is_some() { StockSigningProgress::Unknown } else if self.expected.is_some() { @@ -156,6 +164,7 @@ pub(in crate::workspace) async fn read( } let mut reports = Vec::with_capacity(2); let mut claims = Vec::with_capacity(2); + let mut refusals = Vec::with_capacity(2); let mut summaries = Vec::with_capacity(2); for recipient in auth.original.receipt.rumor().recipients() { let (retained, claim_proof) = @@ -205,13 +214,33 @@ pub(in crate::workspace) async fn read( { return Err(OperationError::RecoveryRequired); } + let unissued = if auth.access.authority.catalog >= 14 { + Box::pin(issuance::unissued::lookup( + turn.connection, + turn.selected, + turn.crypto, + request.operation, + *recipient, + )) + .await? + } else { + None + }; + if unissued + .as_ref() + .is_some_and(|v| reference.is_none_or(|c| c.id != v.receipt().signing_attempt_id())) + { + return Err(OperationError::RecoveryRequired); + } reports.push(StockRecipientSnapshot { recipient: *recipient, expected, claim: reference, count: summary.count, first, + unissued: unissued.as_ref().map(|v| v.receipt()), }); + refusals.push(unissued); claims.push(claim_proof); summaries.push(summary); } @@ -312,6 +341,9 @@ pub(in crate::workspace) async fn read( } for (index, report) in reports.iter().enumerate() { claims[index].confirm(&mut tx).await?; + if let Some(value) = &refusals[index] { + value.confirm(&mut tx).await?; + } summaries[index] .confirm( &mut tx, diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -340,6 +340,13 @@ struct SigningPlanBinding { generic_peer_installed_before_rejected_self_return: bool, unknown_installation_blocks_delivery: bool, native_first_dispatch_owns_issuer_invocation: bool, + shared_first_dispatch_port: String, + shared_unissued_owner: String, + shared_unissued_retained_before_capture: bool, + shared_unissued_drained_before_storage_close: bool, + shared_unissued_failure_blocks_fresh_commands: bool, + public_native_intent_extraction: bool, + coherent_snapshot_preserves_original_unissued: bool, exact_issuer_port: String, native_failure_boundary: String, native_failure_preserves_signer_rejection: bool, @@ -681,6 +688,22 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock .signing_plan_binding .native_first_dispatch_owns_issuer_invocation + && stock.signing_plan_binding.shared_first_dispatch_port + == "radroots_execution.session.commerce.AcceptanceDispatch.dispatch" + && stock.signing_plan_binding.shared_unissued_owner == "ClientSession.stock_captures" + && stock + .signing_plan_binding + .shared_unissued_retained_before_capture + && stock + .signing_plan_binding + .shared_unissued_drained_before_storage_close + && stock + .signing_plan_binding + .shared_unissued_failure_blocks_fresh_commands + && !stock.signing_plan_binding.public_native_intent_extraction + && stock + .signing_plan_binding + .coherent_snapshot_preserves_original_unissued && stock.signing_plan_binding.exact_issuer_port == "radroots_signing.issuance.ExactIssuer" && stock.signing_plan_binding.native_failure_boundary == "radroots_ffi.Error" @@ -1862,6 +1885,19 @@ mod tests { ), ("unknown_installation_blocks_delivery", json!(false)), ("native_first_dispatch_owns_issuer_invocation", json!(false)), + ("shared_first_dispatch_port", json!("into_intent")), + ("shared_unissued_owner", json!("caller_waiter")), + ("shared_unissued_retained_before_capture", json!(false)), + ("shared_unissued_drained_before_storage_close", json!(false)), + ( + "shared_unissued_failure_blocks_fresh_commands", + json!(false), + ), + ("public_native_intent_extraction", json!(true)), + ( + "coherent_snapshot_preserves_original_unissued", + json!(false), + ), ("exact_issuer_port", json!("legacy_signer_fallback")), ("native_failure_boundary", json!("discarded_primitive")), ("native_failure_preserves_signer_rejection", json!(false)),