commit 530c923997f4d586e53477fc385ab11219d88931 parent ed2cd2eabbf16afd96c54913b6030ab3c162ea65 Author: triesap <tyson@radroots.org> Date: Tue, 27 Oct 2026 08:01:21 +0000 storage: release preparations with protected original nonissuance - Bind bounded recipient proofs to retained original claims and refusal facts. - Exclude replay and obtained output inside the exact release transaction. - Preserve legacy cleanup, original evidence and recovery across failures. - Verify native and Linux faults, facade status and binding execution. Diffstat:
15 files changed, 986 insertions(+), 58 deletions(-)
diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -102,7 +102,10 @@ "replay_admission_reauthorizes_current": true, "replay_admission_clear_on_refusal": false, "replay_admission_stock_effect": false, - "retained_untracked_catalogs": [13, 14], + "retained_untracked_catalogs": [ + 13, + 14 + ], "replay_admission_report_is_release_authority": false }, "scope": "seller_stock_owner", @@ -369,10 +372,9 @@ "relay_delivery_claimed": false }, "preparation_abort": { - "payload_version": 1, + "payload_version": 2, "journal_family": 7, "worker_charge_bytes": 1048576, - "all_recipient_claims_must_be_absent": true, "caller_nonissuance_assertion_is_proof": false, "current_exact_recovery_consent_required": true, "atomic_exact_original_release_required": true, @@ -385,7 +387,25 @@ "shared_storage_port": "radroots_storage.inventory.InventoryStore", "shared_model_owner": "radroots_storage.inventory", "native_workspace_type_aliases": false, - "unsupported_hosts_return": "capability_unavailable" + "unsupported_hosts_return": "capability_unavailable", + "retained_payload_versions": [ + 1 + ], + "retained_v1_requires_absent_claims": true, + "claimed_cleanup_catalogs": [ + 15 + ], + "untracked_claimed_catalogs": [ + 13, + 14 + ], + "per_recipient_proof_count": 2, + "original_unissued_required_for_every_claim": true, + "replay_admission_blocks_release": true, + "obtained_evidence_blocks_release": true, + "contradictory_evidence_retained": true, + "contradiction_requires_recovery": true, + "caller_reports_are_release_authority": false } }, "provenance": { diff --git a/crates/execution/src/session/client_inventory.rs b/crates/execution/src/session/client_inventory.rs @@ -239,8 +239,9 @@ impl<H: SessionHost + 'static> ClientSession<H> { .await } - /// Explicitly asks the selected store to prove original claim absence and - /// atomically release only that preparation. Selectors are never proof. + /// Explicitly asks the selected store to prove original nonissuance and + /// replay absence, then atomically release only that preparation. + /// Selectors are never proof. pub async fn abort_proven_unissued( &self, store: Shared<dyn InventoryStore>, diff --git a/crates/execution/src/session/commerce_run.rs b/crates/execution/src/session/commerce_run.rs @@ -97,7 +97,7 @@ pub(crate) fn observe( if snapshot.aborted() && recipients .iter() - .any(|v| v.claim.is_some() || v.evidence.is_some() || v.original_unissued.is_some()) + .any(|v| v.evidence.is_some() || (v.claim.is_some() && v.original_unissued.is_none())) { return Err(OperationError::RecoveryRequired); } diff --git a/crates/radroots/src/native_commerce_tests.rs b/crates/radroots/src/native_commerce_tests.rs @@ -90,6 +90,7 @@ struct Control { signs: AtomicUsize, recoveries: AtomicUsize, fail_self: AtomicBool, + fail_peer: AtomicBool, pause_peer: AtomicBool, entered: tokio::sync::Notify, release: tokio::sync::Notify, @@ -106,6 +107,7 @@ impl Control { signs: AtomicUsize::new(0), recoveries: AtomicUsize::new(0), fail_self: AtomicBool::new(false), + fail_peer: AtomicBool::new(false), pause_peer: AtomicBool::new(false), entered: tokio::sync::Notify::new(), release: tokio::sync::Notify::new(), @@ -155,7 +157,9 @@ impl ParticipantProvider for Provider { Box::pin(async move { 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 (is_self && self.control.fail_self.load(Ordering::SeqCst)) + || (!is_self && self.control.fail_peer.load(Ordering::SeqCst)) + { if self.control.pause_refused.swap(false, Ordering::SeqCst) { self.control.entered.notify_one(); self.control.release.notified().await; diff --git a/crates/radroots/src/native_refusal_tests.rs b/crates/radroots/src/native_refusal_tests.rs @@ -6,6 +6,84 @@ use super::{ }; use sqlx::Connection; +#[tokio::test] +async fn actual_original_refusals_allow_explicit_cleanup_and_aborted_status_never_reissues() { + let r = Rig::new().await; + r.control.fail_peer.store(true, Ordering::SeqCst); + r.control.fail_self.store(true, Ordering::SeqCst); + let (command, original) = r.accept().await; + assert!(!original.aborted()); + assert!(original.installation().is_none()); + for facts in original.recipients() { + assert!(facts.evidence.is_none()); + assert_eq!( + facts.original_unissued.unwrap().claim, + facts.claim.unwrap().id + ); + } + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + let (_, _, minimum) = r.minima().await; + let radroots_storage::inventory::StockAbortOutcome::Aborted(released) = r + .client + .operations(&r.scope) + .abort_proven_unissued(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap() + else { + panic!("actual cleanup must be confirmed"); + }; + let (_, _, minimum) = r.minima().await; + let observed = r + .client + .orders(&r.scope) + .acceptance_status(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert!(observed.aborted()); + assert!(observed.installation().is_none()); + assert!(observed.recipients() == original.recipients()); + r.control.fail_peer.store(false, Ordering::SeqCst); + r.control.fail_self.store(false, Ordering::SeqCst); + let resumed = r + .client + .orders(&r.scope) + .resume_acceptance(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert!(resumed.aborted()); + assert!(resumed.recipients() == original.recipients()); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); + assert_eq!( + r.client + .operations(&r.scope) + .preparation_abort(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap() + .unwrap() + .attempt(), + released.attempt() + ); + let mut raw = sqlx::SqliteConnection::connect(&format!( + "sqlite://{}", + r._temp + .path() + .join("stock/stock_execution_v1.sqlite") + .display() + )) + .await + .unwrap(); + let facts: (i64, i64, i64, i64, i64) = sqlx::query_as( + "SELECT (SELECT count(*) FROM stock_signing_claims),(SELECT count(*) FROM stock_original_unissued),(SELECT count(*) FROM stock_signing_evidence),(SELECT count(*) FROM stock_replay_admissions),(SELECT count(*) FROM stock_aborts)", + ) + .fetch_one(&mut raw) + .await + .unwrap(); + assert_eq!(facts, (2, 2, 0, 0, 1)); + raw.close().await.unwrap(); + r.client.close().await.unwrap(); +} + 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())) diff --git a/crates/radroots/src/operations.rs b/crates/radroots/src/operations.rs @@ -9,7 +9,8 @@ pub struct Operations<'a> { } impl<'a> Operations<'a> { /// Explicitly requests original preparation cleanup. Only the selected - /// store can prove all original claims absent and release the exact hold. + /// store can prove original nonissuance and replay absence, then release + /// the exact hold while retaining the original claims and facts. /// This is separate from business cancellation and stopping delivery. pub async fn abort_proven_unissued( &self, diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs @@ -299,8 +299,9 @@ pub trait InventoryStore: WorkspaceStore { Box::pin(async { Err(OperationError::UnsupportedOperation) }) } /// Explicit original-preparation cleanup. The concrete store must prove - /// every original claim absent and retain the exact release atomically. - /// Neither this port nor an unsupported host supplies an absence proof. + /// every original invocation unissued, exclude outstanding replay and + /// obtained output, and retain the exact release atomically. Neither this + /// port nor an unsupported host supplies those proofs. fn abort_proven_unissued( &self, _request: StockAbortRequest, diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort.rs @@ -1,10 +1,11 @@ -//! Explicit release of original preparation only when every claim is absent. -use super::super::{issuance::claim, ledger, order_state, signing_plan}; +//! Explicit release after authenticated original nonissuance and replay absence. +use super::super::{ledger, order_state, signing_plan}; use super::*; use checkpoint::{EntryIdentity, IdentityTarget}; use radroots_domain::stock::StockTicks; mod codec; mod projection; +mod proof; pub(in crate::workspace::stock) use codec::read_entry; pub(in crate::workspace::stock) use projection::{Projection, raw_projection}; @@ -33,6 +34,8 @@ struct Body { aborted_at: UnixSeconds, authorization: StockAuthorizationRef, effects: Vec<Effect>, + #[serde(default, skip_serializing_if = "proof::Payload::legacy")] + proofs: proof::Payload, } fn after(before: PoolSnapshot, quantity: StockTicks) -> Result<PoolSnapshot, OperationError> { let balances = before @@ -149,6 +152,14 @@ pub(in crate::workspace) async fn abort( &proof, )) .await?; + Box::pin(abort_authorized(turn, request, proof, auth)).await +} +async fn abort_authorized( + turn: &mut Turn<'_>, + request: StockAbortRequest, + proof: AttachmentProof, + auth: signing_plan::Authorized, +) -> Result<StockAbortOutcome, OperationError> { if !matches!(auth.access.authority.catalog, 13..=15) { return Err(OperationError::UnsupportedOperation); } @@ -180,26 +191,7 @@ pub(in crate::workspace) async fn abort( }) { return Err(OperationError::StaleState); } - let mut claims = Vec::with_capacity(2); - for recipient in auth.original.receipt.rumor().recipients() { - let (claim, witness) = Box::pin(claim::existing( - turn, - &auth, - request.operation_id(), - *recipient, - )) - .await?; - if claim.is_some() { - return Err(OperationError::RecoveryRequired); - } - claims.push(witness); - } - no_claims( - turn.connection, - turn.selected.participant(), - request.operation_id(), - ) - .await?; + let nonissuance = Box::pin(proof::prepare(turn, &auth, request.operation_id(), at)).await?; let backing = Box::pin(super::backing::read( turn, &auth.access, @@ -236,7 +228,7 @@ pub(in crate::workspace) async fn abort( ) .map_err(|_| WorkspaceError::Capacity)?; let body = Body { - version: 1, + version: if nonissuance.payload.legacy() { 1 } else { 2 }, operation: request.operation_id(), original_head: auth.original.frame.header.head, plan: auth.plan.as_ref().map(|plan| Plan { @@ -250,6 +242,7 @@ pub(in crate::workspace) async fn abort( .authorization .ok_or(OperationError::RecoveryRequired)?, effects, + proofs: nonissuance.payload.clone(), }; let clear = zeroize::Zeroizing::new( serde_json::to_vec(&body).map_err(|_| OperationError::StorageFailure)?, @@ -276,7 +269,7 @@ pub(in crate::workspace) async fn abort( parts: 0, body_digest: [0; 32], }; - header.head = codec::head(&header, &clear); + header.head = codec::head(&header, &clear, body.version)?; let projection = Projection::new(&header, &body)?; let framed = ledger::prepare(turn.crypto, turn.selected, header, &clear).await?; let receipt = codec::receipt(turn.selected, &framed.header, &body)?; @@ -340,8 +333,7 @@ pub(in crate::workspace) async fn abort( .map_err(|_| OperationError::StorageFailure)?; let changed:Result<(),OperationError>=async { Box::pin(identity.confirm(&mut tx)).await?; - for claim in &claims {Box::pin(claim.confirm(&mut tx)).await?;} - no_claims(&mut tx,turn.selected.participant(),request.operation_id()).await?; + Box::pin(nonissuance.confirm(&mut tx)).await?; let checked=Box::pin(auth.confirm(&mut tx,turn.namespace,turn.clock,&proof,false)).await?; if checked.observed_at()<at {return Err(WorkspaceError::Unavailable.into());} for pool in &backing {Box::pin(pool.confirm(&mut tx)).await?;} diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort/codec.rs @@ -15,10 +15,19 @@ pub(in crate::workspace::stock) struct Retained { projection: Projection, plan: Option<Plan>, movements: Vec<ledger::MovementWitness>, + nonissuance: proof::Witness, } -pub(super) fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { +pub(super) fn head( + header: &ledger::Header, + body: &[u8], + version: u8, +) -> Result<CheckpointDigest, OperationError> { let mut hash = Sha256::new(); - hash.update(b"radroots.seller_stock.abort_chain.v1\0"); + hash.update(match version { + 1 => b"radroots.seller_stock.abort_chain.v1\0".as_slice(), + 2 => b"radroots.seller_stock.abort_chain.v2\0".as_slice(), + _ => return Err(OperationError::RecoveryRequired), + }); hash.update(header.namespace.workspace_id().as_bytes()); hash.update(header.namespace.authority().executor_id().as_bytes()); hash.update( @@ -45,7 +54,7 @@ pub(super) fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { hash.update([u8::from(header.previous.is_some())]); hash.update(header.previous.map(|id| *id.as_bytes()).unwrap_or([0; 32])); hash.update(Sha256::digest(body)); - CheckpointDigest::from_bytes(hash.finalize().into()) + Ok(CheckpointDigest::from_bytes(hash.finalize().into())) } pub(super) fn receipt( input: &AttachmentInput, @@ -106,9 +115,9 @@ pub(in crate::workspace::stock) async fn read_entry( } let body: Body = super::super::super::closed_record(&frame.body) .map_err(|_| OperationError::RecoveryRequired)?; - if body.version != 1 + if !matches!((body.version, body.proofs.legacy()), (1, true) | (2, false)) || header.related_operation != Some(body.operation) - || head(header, &frame.body) != header.head + || head(header, &frame.body, body.version)? != header.head || body.effects.len() > 64 { return Err(OperationError::RecoveryRequired); @@ -150,7 +159,15 @@ pub(in crate::workspace::stock) async fn read_entry( return Err(OperationError::RecoveryRequired); } } - no_claims(connection, input.participant(), body.operation).await?; + let nonissuance = Box::pin(proof::read( + connection, + input, + crypto, + &body, + header, + original.receipt.rumor().recipients(), + )) + .await?; let quantities = original.held_allocations()?; if quantities.len() != body.effects.len() { return Err(OperationError::RecoveryRequired); @@ -225,6 +242,7 @@ pub(in crate::workspace::stock) async fn read_entry( frame, plan: body.plan, movements, + nonissuance, }; value.confirm(connection).await?; Ok(Some(value)) @@ -255,12 +273,7 @@ impl Retained { self.frame.header.operation, ) .await?; - no_claims( - connection, - self.frame.header.actor.participant(), - self.projection.operation, - ) - .await?; + Box::pin(self.nonissuance.confirm(connection)).await?; plan_selector( connection, self.frame.header.actor.participant(), diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort/proof.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort/proof.rs @@ -0,0 +1,302 @@ +//! Protected original nonissuance and current-catalog replay absence. +use super::super::super::issuance::{claim, unissued}; +use super::*; +use radroots_domain::PublicKey; +use serde::{Deserializer, Serializer}; +use sha2::{Digest, Sha256}; + +#[derive(Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] +#[serde(deny_unknown_fields)] +pub(super) struct Record { + operation: OperationId, + revision: Sequence, + head: CheckpointDigest, + protected_digest: [u8; 32], +} +impl From<EntryIdentity> for Record { + fn from(v: EntryIdentity) -> Self { + Self { + operation: v.operation, + revision: v.revision, + head: v.head, + protected_digest: v.protected_digest, + } + } +} +fn claim_record(v: &claim::codec::Retained) -> Record { + Record { + operation: v.frame.header.operation, + revision: v.frame.header.revision, + head: v.frame.header.head, + protected_digest: Sha256::digest(&v.frame.protected).into(), + } +} +#[derive(Clone, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)] +pub(super) enum Recipient { + Absent { + recipient: PublicKey, + }, + OriginalUnissued { + recipient: PublicKey, + claim: Box<Record>, + unissued: Box<Record>, + }, +} +impl Recipient { + fn recipient(&self) -> PublicKey { + match self { + Self::Absent { recipient } | Self::OriginalUnissued { recipient, .. } => *recipient, + } + } +} +/// Missing is distinct from a present null/empty field in retained payload1. +#[derive(Clone, Default)] +pub(super) enum Payload { + #[default] + Legacy, + Current(Box<[Recipient; 2]>), +} +impl Payload { + pub(super) fn legacy(&self) -> bool { + matches!(self, Self::Legacy) + } +} +impl Serialize for Payload { + fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> { + match self { + Self::Legacy => Err(serde::ser::Error::custom("missing cleanup proof")), + Self::Current(v) => v.serialize(s), + } + } +} +impl<'de> Deserialize<'de> for Payload { + fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> { + <Box<[Recipient; 2]>>::deserialize(d).map(Self::Current) + } +} +struct Known { + claim: claim::codec::Retained, + negative: unissued::Retained, +} +pub(super) struct Witness { + pub(super) payload: Payload, + operation: OperationId, + actor: PublicKey, + minimum: Vec<MinimumProof>, + known: Vec<Known>, +} +async fn no_risks( + connection: &mut SqliteConnection, + actor: PublicKey, + operation: OperationId, +) -> Result<(), OperationError> { + let risk:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM stock_signing_evidence WHERE actor=? AND operation_id=?) OR EXISTS(SELECT 1 FROM stock_agreements WHERE actor=? AND operation_id=?) OR EXISTS(SELECT 1 FROM stock_replay_admissions WHERE actor=? AND operation_id=?) OR EXISTS(SELECT 1 FROM stock_operations WHERE actor=? AND related_operation=? AND family IN (5,6,9))") + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()) + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()) + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()) + .bind(actor.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()) + .fetch_one(connection).await.map_err(|_|OperationError::RecoveryRequired)?; + if risk { + return Err(OperationError::RecoveryRequired); + } + Ok(()) +} +impl Witness { + pub(super) async fn confirm( + &self, + connection: &mut SqliteConnection, + ) -> Result<(), OperationError> { + for proof in &self.minimum { + Box::pin(proof.confirm(connection)).await?; + } + if self.payload.legacy() { + return no_claims(connection, self.actor, self.operation).await; + } + no_risks(connection, self.actor, self.operation).await?; + let claims: i64 = sqlx::query_scalar( + "SELECT count(*) FROM stock_signing_claims WHERE actor=? AND operation_id=?", + ) + .bind(self.actor.as_bytes().as_slice()) + .bind(self.operation.as_bytes().as_slice()) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if claims != self.known.len() as i64 { + return Err(OperationError::RecoveryRequired); + } + for value in &self.known { + Box::pin(value.claim.confirm(connection)).await?; + Box::pin(value.negative.confirm(connection)).await?; + } + Ok(()) + } +} +pub(super) async fn prepare( + turn: &mut Turn<'_>, + auth: &signing_plan::Authorized, + operation: OperationId, + at: UnixSeconds, +) -> Result<Witness, OperationError> { + let mut minimum = Vec::with_capacity(2); + let mut known = Vec::with_capacity(2); + let mut encoded = Vec::with_capacity(2); + for recipient in auth.original.receipt.rumor().recipients() { + let (original, proof) = + Box::pin(claim::existing(turn, auth, operation, *recipient)).await?; + minimum.push(proof); + match original { + None => encoded.push(Recipient::Absent { + recipient: *recipient, + }), + Some(original) => { + if auth.access.authority.catalog != 15 { + return Err(OperationError::RecoveryRequired); + } + if at < original.report.claimed_at() { + return Err(WorkspaceError::Unavailable.into()); + } + let negative = Box::pin(unissued::lookup( + turn.connection, + turn.selected, + turn.crypto, + operation, + *recipient, + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if negative.receipt().signing_attempt_id() != original.report.attempt_id() { + return Err(OperationError::RecoveryRequired); + } + encoded.push(Recipient::OriginalUnissued { + recipient: *recipient, + claim: Box::new(claim_record(&original)), + unissued: Box::new(negative.identity().into()), + }); + known.push(Known { + claim: original, + negative, + }); + } + } + } + let payload = if auth.access.authority.catalog == 15 { + Payload::Current(Box::new( + encoded + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + )) + } else { + Payload::Legacy + }; + let value = Witness { + payload, + operation, + actor: turn.selected.participant(), + minimum, + known, + }; + Box::pin(value.confirm(turn.connection)).await?; + Ok(value) +} +pub(super) async fn read( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + body: &Body, + header: &ledger::Header, + recipients: &[PublicKey; 2], +) -> Result<Witness, OperationError> { + let operation = body.operation; + let at = body.aborted_at; + let revision = header.revision; + let payload = body.proofs.clone(); + let mut known = Vec::with_capacity(2); + if let Payload::Current(proofs) = &payload { + let catalog: i64 = sqlx::query_scalar("PRAGMA user_version") + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if catalog != 15 { + return Err(OperationError::RecoveryRequired); + } + for (proof, expected) in proofs.iter().zip(recipients) { + if proof.recipient() != *expected { + return Err(OperationError::RecoveryRequired); + } + if let Recipient::OriginalUnissued { + claim: reference, + unissued: negative_ref, + .. + } = proof + { + let original = Box::pin(claim::read_entry( + connection, + input, + crypto, + reference.operation, + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + let negative = Box::pin(unissued::lookup( + connection, input, crypto, operation, *expected, + )) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if claim_record(&original) != **reference + || Record::from(negative.identity()) != **negative_ref + || original.report.attempt().operation_id() != operation + || original.report.recipient() != *expected + || original.report.claimed_at() > at + || negative.receipt().signing_attempt_id() != original.report.attempt_id() + || reference.revision >= revision + || negative_ref.revision >= revision + { + return Err(OperationError::RecoveryRequired); + } + known.push(Known { + claim: original, + negative, + }); + } + } + } + let value = Witness { + payload, + operation, + actor: input.participant(), + minimum: vec![], + known, + }; + Box::pin(value.confirm(connection)).await?; + Ok(value) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn proof_wire_requires_two_nonnull_entries_and_rejects_duplicate_fields() { + let key = crate::workspace::tests::participant(); + let entry = serde_json::json!({"kind":"absent","recipient":key}); + let good = serde_json::to_string(&[entry.clone(), entry.clone()]).unwrap(); + assert!(serde_json::from_str::<Payload>(&good).is_ok()); + for bad in [ + "null".into(), + "[]".into(), + serde_json::to_string(std::slice::from_ref(&entry)).unwrap(), + serde_json::to_string(&[entry.clone(), entry.clone(), entry]).unwrap(), + good.replace( + "\"kind\":\"absent\"", + "\"kind\":\"absent\",\"kind\":\"absent\"", + ), + good.replace( + "\"kind\":\"absent\"", + "\"kind\":\"absent\",\"release\":true", + ), + ] { + assert!(serde_json::from_str::<Payload>(&bad).is_err()); + } + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/issuance/unissued.rs b/crates/storage_sqlite/src/workspace/stock/issuance/unissued.rs @@ -178,6 +178,14 @@ pub(in crate::workspace::stock) struct Retained { projection: Projection, } impl Retained { + pub(in crate::workspace::stock) fn identity(&self) -> checkpoint::EntryIdentity { + checkpoint::EntryIdentity { + operation: self.frame.header.operation, + revision: self.frame.header.revision, + head: self.frame.header.head, + protected_digest: Sha256::digest(&self.frame.protected).into(), + } + } pub(in crate::workspace::stock) fn receipt(&self) -> StockUnissuedReceipt { *self.value } diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/abort_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/abort_tests.rs @@ -8,6 +8,8 @@ use super::*; use radroots_storage::inventory::{ InventoryStore, StockAbortOutcome, StockAbortReceipt, StockAbortRequest, }; +#[path = "claimed_abort_tests.rs"] +mod claimed; #[path = "abort_failures_tests.rs"] mod failures; @@ -41,8 +43,8 @@ pub(super) fn released(value: StockAbortOutcome) -> StockAbortReceipt { } #[tokio::test] async fn unclaimed_preparation_aborts_before_or_after_t1_and_originals_survive_new_order_attempt() { - for has_plan in [false, true] { - let mut r = Rig::new().await; + for (catalog, has_plan) in [(13, false), (14, true), (15, false), (15, true)] { + let mut r = Rig::with_catalog(catalog).await; let (command, receipt) = Box::pin(prepared(&r)).await; if has_plan { bound(bind(&r, &receipt, 42).await.unwrap()); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/claimed_abort_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/claimed_abort_tests.rs @@ -0,0 +1,474 @@ +//! Actual current cleanup, replay risk and retained contradictory evidence. +use super::*; +use crate::workspace::{ + StockDispatchOutcome, StockEvidenceCapture, StockSigningAttempt, StockUnissuedOutcome, +}; +use radroots_signing::issuance::{ExactIssuer, ExactRecoveryKind, OutcomeKind}; +use radroots_storage::inventory::StockEvidenceOutcome; + +async fn replay_ready(r: &Rig) -> StockAcceptanceReceipt { + let (_, receipt) = prepared(r).await; + let candidate = candidate_with_replay(r, &receipt, 42, SigningReplay::LocalReplaySafe).await; + bound( + r.store + .bind_stock_signing_intents( + StockSigningPlanRequest::new( + r.binding.clone(), + inventory_minimum(r).await, + candidate, + ) + .unwrap(), + r.enrollment.proof(), + ) + .await + .unwrap(), + ); + receipt +} +fn local() -> LocalSigner { + LocalSigner::with_clock(SecretKey::parse(&format!("{:064x}", 3)).unwrap(), || { + Ok(150000) + }) + .unwrap() +} +async fn refused( + r: &Rig, + receipt: &StockAcceptanceReceipt, + recipient: PublicKey, + persist: bool, +) -> StockSigningAttempt { + let StockClaimOutcome::Fresh(permit) = claim(r, receipt, recipient).await.unwrap() else { + panic!("original claim") + }; + let report = permit.report().clone(); + let cancellation = CancellationSignal::new(); + cancellation.cancel(); + let signer = local(); + let StockDispatchOutcome::Unissued(value) = + permit.dispatch(&signer, cancellation).await.unwrap() + else { + panic!("actual original local refusal") + }; + if persist { + assert!(matches!( + r.store + .capture_stock_original_unissued(r.binding.clone(), &value, r.enrollment.proof()) + .await + .unwrap(), + StockUnissuedOutcome::Committed(_) + )); + } + report +} +async fn snapshot( + r: &Rig, + receipt: &StockAcceptanceReceipt, +) -> crate::workspace::StockOperationSnapshot { + r.store + .stock_operation_snapshot( + StockSnapshotRequest::new( + r.binding.clone(), + inventory_minimum(r).await, + receipt.attempt().operation_id(), + receipt.attempt().command_digest(), + ), + r.enrollment.proof(), + ) + .await + .unwrap() +} +#[tokio::test] +async fn current_claimed_cleanup_releases_exact_originals_once_and_preserves_every_fact() { + for count in [1, 2] { + let mut r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + let mut original = Vec::new(); + for recipient in receipt.rumor().recipients().iter().take(count) { + original.push(refused(&r, &receipt, *recipient, true).await); + } + let before = inventory_minimum(&r).await; + let first = released(abort(&r, &receipt).await.unwrap()); + assert_eq!( + first.checkpoint().revision().get(), + before.revision().get() + 1 + ); + balances(&r, 80, 10, 0, 0, 3).await; + balances(&r, 81, 10, 0, 0, 3).await; + let view = snapshot(&r, &receipt).await; + assert_eq!(view.aborted().unwrap().attempt(), first.attempt()); + assert_eq!( + view.recipients() + .iter() + .filter(|v| v.claim().is_some()) + .count(), + count + ); + for v in view.recipients() { + assert_eq!(v.claim().is_some(), v.original_unissued().is_some()); + assert!(v.first_evidence().is_none() && v.replay_admission().is_none()); + } + let acknowledged = inventory_minimum(&r).await; + reopen_plain(&mut r).await; + assert_eq!( + released(abort(&r, &receipt).await.unwrap()).attempt(), + first.attempt() + ); + assert_eq!(inventory_minimum(&r).await, acknowledged); + for original in &original { + let selected = selector(&r, &receipt, original.recipient()).await; + assert_eq!( + r.store + .stock_signing_attempt(selected, r.enrollment.proof()) + .await + .unwrap() + .unwrap() + .attempt_id(), + original.attempt_id() + ); + let StockClaimOutcome::Existing(again) = + claim(&r, &receipt, original.recipient()).await.unwrap() + else { + panic!("an aborted original cannot return fresh dispatch permission"); + }; + assert_eq!(again.attempt_id(), original.attempt_id()); + assert!( + r.store + .authorize_stock_exact_replay( + selector(&r, &receipt, original.recipient()).await, + r.enrollment.proof() + ) + .await + .is_err() + ); + } + let mut raw = database(&r).await; + for (query, expected) in [ + ("SELECT count(*) FROM stock_signing_claims", count as i64), + ("SELECT count(*) FROM stock_original_unissued", count as i64), + ("SELECT count(*) FROM stock_signing_evidence", 0), + ("SELECT count(*) FROM stock_aborts", 1), + ] { + let actual: i64 = sqlx::query_scalar(query).fetch_one(&mut raw).await.unwrap(); + assert_eq!(actual, expected); + } + raw.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} +#[tokio::test] +async fn unrecorded_original_refusal_and_untracked_retained_claims_never_authorize_cleanup() { + for catalog in [14, 15] { + let r = if catalog == 14 { + Rig::with_catalog(catalog).await + } else { + Rig::new().await + }; + let receipt = Box::pin(replay_ready(&r)).await; + refused(&r, &receipt, peer(&r, &receipt), catalog == 14).await; + let before = inventory_minimum(&r).await; + assert_eq!( + abort(&r, &receipt).await.unwrap_err().code(), + "recovery_required" + ); + assert_eq!(inventory_minimum(&r).await, before); + balances(&r, 80, 9, 1, 0, 2).await; + balances(&r, 81, 8, 2, 0, 2).await; + r.store.close().await.unwrap(); + } +} +#[tokio::test] +async fn held_replay_permission_prevents_release_and_late_original_output_stays_installable() { + let r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + for recipient in receipt.rumor().recipients() { + refused(&r, &receipt, *recipient, true).await; + } + let recipient = peer(&r, &receipt); + let permit = r + .store + .authorize_stock_exact_replay( + selector(&r, &receipt, recipient).await, + r.enrollment.proof(), + ) + .await + .unwrap(); + assert!(permit.admission().is_some()); + assert_eq!( + abort(&r, &receipt).await.unwrap_err().code(), + "recovery_required" + ); + balances(&r, 80, 9, 1, 0, 2).await; + let call = ProviderCall::new( + r.enrollment.input().participant(), + NonZeroU64::new(250000).unwrap(), + CancellationSignal::new(), + ); + let (request, report) = permit.into_recovery_request(call).unwrap(); + let outcome = local().recover_exact(request).await; + let (_, ExactRecoveryKind::Obtained(signed)) = outcome.into_parts() else { + panic!("original recovered output") + }; + let capture = signed + .with_json(|raw| StockEvidenceCapture::verify(r.binding.clone(), &report, raw, None)) + .unwrap(); + assert!(matches!( + r.store + .capture_stock_signing_evidence(&capture, r.enrollment.proof()) + .await + .unwrap(), + StockEvidenceOutcome::Committed(_) + )); + installed(install(&r, &receipt).await.unwrap()); + assert_eq!(abort(&r, &receipt).await.unwrap_err().code(), "stale_state"); + let view = snapshot(&r, &receipt).await; + assert!(view.aborted().is_none() && view.installation().is_some()); + assert!( + view.recipients() + .iter() + .all(|v| v.original_unissued().is_some()) + ); + balances(&r, 80, 9, 0, 1, 3).await; + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn every_claimed_cleanup_write_fault_rolls_back_release_and_keeps_original_proofs() { + for statement in [ + "CREATE TRIGGER fault BEFORE INSERT ON stock_operations WHEN NEW.family=7 BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE INSERT ON stock_operation_parts BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE INSERT ON stock_aborts BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE UPDATE ON stock_pools BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE INSERT ON stock_movements BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE UPDATE ON stock_order_states BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE UPDATE ON stock_authority BEGIN SELECT RAISE(ABORT,'fixture'); END", + ] { + let r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + refused(&r, &receipt, peer(&r, &receipt), true).await; + let before = inventory_minimum(&r).await; + let mut raw = database(&r).await; + sqlx::query(statement).execute(&mut raw).await.unwrap(); + assert_eq!( + abort(&r, &receipt).await.unwrap_err().code(), + "storage_failure", + "{statement}" + ); + assert_eq!(inventory_minimum(&r).await, before); + balances(&r, 80, 9, 1, 0, 2).await; + balances(&r, 81, 8, 2, 0, 2).await; + assert!(snapshot(&r, &receipt).await.aborted().is_none()); + sqlx::query("DROP TRIGGER fault") + .execute(&mut raw) + .await + .unwrap(); + raw.close().await.unwrap(); + released(abort(&r, &receipt).await.unwrap()); + balances(&r, 80, 10, 0, 0, 3).await; + r.store.close().await.unwrap(); + } +} +#[tokio::test] +async fn uncertain_claimed_cleanup_fences_owner_and_reopens_without_erasing_claims_or_facts() { + let mut r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + refused(&r, &receipt, peer(&r, &receipt), true).await; + let request = abort_request(&r, &receipt).await; + let mut raw = database(&r).await; + sqlx::raw_sql("CREATE TABLE cleanup_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER fault AFTER INSERT ON stock_aborts BEGIN INSERT INTO cleanup_deferred_fault VALUES(2); END").execute(&mut raw).await.unwrap(); + assert!(matches!( + r.store + .abort_proven_unissued(request, r.enrollment.proof()) + .await + .unwrap(), + StockAbortOutcome::Unknown(_) + )); + let request = StockAbortRequest::new( + r.binding.clone(), + receipt.checkpoint(), + receipt.attempt().operation_id(), + receipt.attempt().command_digest(), + ); + assert_eq!( + r.store + .abort_proven_unissued(request, r.enrollment.proof()) + .await + .unwrap_err() + .code(), + "recovery_required" + ); + sqlx::raw_sql("DROP TRIGGER fault; DROP TABLE cleanup_deferred_fault") + .execute(&mut raw) + .await + .unwrap(); + raw.close().await.unwrap(); + reopen_plain(&mut r).await; + assert!(snapshot(&r, &receipt).await.aborted().is_none()); + released(abort(&r, &receipt).await.unwrap()); + balances(&r, 80, 10, 0, 0, 3).await; + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn contradictory_late_signed_bytes_are_retained_and_fence_fresh_stock() { + let r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + let report = refused(&r, &receipt, peer(&r, &receipt), true).await; + released(abort(&r, &receipt).await.unwrap()); + // Deliberately model a root-key holder signing outside executor permission. + // This contradicts the original qualified nonissuance fact; it is not replay. + let intent = crate::workspace::stock::issuance::claim::intent( + report.bound_plan(), + report.recipient(), + CancellationSignal::new(), + ) + .unwrap(); + let (_, OutcomeKind::Obtained(signed)) = local().issue_exact(intent).await.into_parts() else { + panic!("actual contradictory signature") + }; + let text = signed.with_json(str::to_owned); + let capture = StockEvidenceCapture::verify(r.binding.clone(), &report, &text, None).unwrap(); + let StockEvidenceOutcome::Committed(retained) = r + .store + .capture_stock_signing_evidence(&capture, r.enrollment.proof()) + .await + .unwrap() + else { + panic!("retain obtained bytes") + }; + assert_eq!(retained.signing_attempt_id(), report.attempt_id()); + let current = inventory_minimum(&r).await; + let request = StockSnapshotRequest::new( + r.binding.clone(), + current, + receipt.attempt().operation_id(), + receipt.attempt().command_digest(), + ); + assert_eq!( + r.store + .stock_operation_snapshot(request, r.enrollment.proof()) + .await + .unwrap_err() + .code(), + "recovery_required" + ); + let wire = serde_json::json!({"type":"stock.create_pool","context":context(&r,98),"input":{"id":pool(98),"label":"blocked after contradictory evidence","unit":"each","tick_scale":"0","initial_quantity":"1"}}); + let command = radroots_storage::inventory::InventoryRequest::from_protected_wire( + r.binding.clone(), + current, + &serde_json::to_vec(&wire).unwrap(), + ) + .unwrap(); + assert_eq!( + r.store + .execute_inventory( + command, + r.enrollment + .proof() + .with_secret(|v| AttachmentProof::from_protected_input(v)) + .unwrap() + ) + .await + .unwrap_err() + .code(), + "recovery_required" + ); + let mut raw = database(&r).await; + let entry: Vec<u8> = sqlx::query_scalar("SELECT entry_id FROM stock_signing_evidence") + .fetch_one(&mut raw) + .await + .unwrap(); + let decoded = Box::pin(crate::workspace::stock::issuance::evidence::read_entry( + &mut raw, + r.enrollment.input(), + &r.fixture.crypto(), + OperationId::from_bytes(entry.try_into().unwrap()), + )) + .await + .unwrap() + .unwrap(); + decoded.value.with_json(|value| assert_eq!(value, text)); + let fresh: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_pools WHERE pool_id=?") + .bind(pool(98).as_bytes().as_slice()) + .fetch_one(&mut raw) + .await + .unwrap(); + assert_eq!(fresh, 0); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn lost_claimed_cleanup_waiter_drains_before_reopen_and_keeps_original_proofs() { + let mut r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + refused(&r, &receipt, peer(&r, &receipt), true).await; + let request = abort_request(&r, &receipt).await; + let provider = reopen(&mut r).await; + provider + .gate + .arm(Direction::Wrap, "radroots.seller_stock.authority.v15", 0); + let mut pending = Box::pin(r.store.abort_proven_unissued(request, r.enrollment.proof())); + assert!(futures::poll!(pending.as_mut()).is_pending()); + provider.gate.entered(); + drop(pending); + let mut closing = Box::pin(r.store.close()); + assert!(futures::poll!(closing.as_mut()).is_pending()); + provider.gate.release(); + closing.await.unwrap(); + reopen_plain(&mut r).await; + let view = snapshot(&r, &receipt).await; + let original = view.aborted().unwrap().attempt(); + assert_eq!( + view.recipients() + .iter() + .filter(|v| v.original_unissued().is_some()) + .count(), + 1 + ); + assert_eq!( + released(abort(&r, &receipt).await.unwrap()).attempt(), + original + ); + balances(&r, 80, 10, 0, 0, 3).await; + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn damaged_original_fact_never_becomes_release_permission_or_an_automatic_repair() { + for statement in [ + "DELETE FROM stock_original_unissued", + "UPDATE stock_original_unissued SET entry_id=randomblob(32)", + "UPDATE stock_operation_parts SET protected=randomblob(length(protected)) WHERE operation_id IN (SELECT entry_id FROM stock_original_unissued)", + ] { + let r = Rig::new().await; + let receipt = Box::pin(replay_ready(&r)).await; + refused(&r, &receipt, peer(&r, &receipt), true).await; + let request = abort_request(&r, &receipt).await; + let mut raw = database(&r).await; + let before: Vec<(Vec<u8>, i64, Vec<u8>)> = + sqlx::query_as("SELECT pool_id,revision,protected FROM stock_pools ORDER BY pool_id") + .fetch_all(&mut raw) + .await + .unwrap(); + sqlx::query(statement).execute(&mut raw).await.unwrap(); + assert_eq!( + r.store + .abort_proven_unissued(request, r.enrollment.proof()) + .await + .unwrap_err() + .code(), + "recovery_required", + "{statement}" + ); + let after: Vec<(Vec<u8>, i64, Vec<u8>)> = + sqlx::query_as("SELECT pool_id,revision,protected FROM stock_pools ORDER BY pool_id") + .fetch_all(&mut raw) + .await + .unwrap(); + assert_eq!(after, before); + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_aborts") + .fetch_one(&mut raw) + .await + .unwrap(); + assert_eq!(count, 0); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/unissued_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/unissued_tests.rs @@ -52,9 +52,9 @@ async fn read_fact( .await } #[tokio::test] -async fn qualified_original_refusals_are_durable_idempotent_and_keep_holds_without_clock() { +async fn retained_v14_original_refusals_are_durable_idempotent_and_keep_holds_without_clock() { for mode in 0..4 { - let mut r = Rig::new().await; + let mut r = Rig::with_catalog(14).await; let receipt = ready(&r).await; assert!(read_fact(&r, &receipt).await.unwrap().is_none()); let value = observation(&r, &receipt, mode).await; diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -266,7 +266,17 @@ struct PreparationAbort { payload_version: u32, journal_family: u32, worker_charge_bytes: u32, - all_recipient_claims_must_be_absent: bool, + retained_payload_versions: Vec<u32>, + retained_v1_requires_absent_claims: bool, + claimed_cleanup_catalogs: Vec<u32>, + untracked_claimed_catalogs: Vec<u32>, + per_recipient_proof_count: u32, + original_unissued_required_for_every_claim: bool, + replay_admission_blocks_release: bool, + obtained_evidence_blocks_release: bool, + contradictory_evidence_retained: bool, + contradiction_requires_recovery: bool, + caller_reports_are_release_authority: bool, caller_nonissuance_assertion_is_proof: bool, current_exact_recovery_consent_required: bool, atomic_exact_original_release_required: bool, @@ -939,7 +949,7 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && !stock .qualified_local_recovery .replay_admission_report_is_release_authority - && stock.preparation_abort.payload_version == 1 + && stock.preparation_abort.payload_version == 2 && stock.preparation_abort.journal_family == 7 && stock.preparation_abort.worker_charge_bytes == 1048576 && stock.preparation_abort.shared_storage_port @@ -947,7 +957,19 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.preparation_abort.shared_model_owner == "radroots_storage.inventory" && !stock.preparation_abort.native_workspace_type_aliases && stock.preparation_abort.unsupported_hosts_return == "capability_unavailable" - && stock.preparation_abort.all_recipient_claims_must_be_absent + && stock.preparation_abort.retained_payload_versions == [1] + && stock.preparation_abort.retained_v1_requires_absent_claims + && stock.preparation_abort.claimed_cleanup_catalogs == [15] + && stock.preparation_abort.untracked_claimed_catalogs == [13, 14] + && stock.preparation_abort.per_recipient_proof_count == 2 + && stock + .preparation_abort + .original_unissued_required_for_every_claim + && stock.preparation_abort.replay_admission_blocks_release + && stock.preparation_abort.obtained_evidence_blocks_release + && stock.preparation_abort.contradictory_evidence_retained + && stock.preparation_abort.contradiction_requires_recovery + && !stock.preparation_abort.caller_reports_are_release_authority && !stock .preparation_abort .caller_nonissuance_assertion_is_proof @@ -1745,10 +1767,20 @@ mod tests { ("shared_model_owner", json!("radroots_storage_sqlite")), ("native_workspace_type_aliases", json!(true)), ("unsupported_hosts_return", json!("aborted")), - ("payload_version", json!(2)), + ("payload_version", json!(3)), ("journal_family", json!(6)), ("worker_charge_bytes", json!(1048577)), - ("all_recipient_claims_must_be_absent", json!(false)), + ("retained_payload_versions", json!([])), + ("retained_v1_requires_absent_claims", json!(false)), + ("claimed_cleanup_catalogs", json!([14, 15])), + ("untracked_claimed_catalogs", json!([13])), + ("per_recipient_proof_count", json!(1)), + ("original_unissued_required_for_every_claim", json!(false)), + ("replay_admission_blocks_release", json!(false)), + ("obtained_evidence_blocks_release", json!(false)), + ("contradictory_evidence_retained", json!(false)), + ("contradiction_requires_recovery", json!(false)), + ("caller_reports_are_release_authority", json!(true)), ("caller_nonissuance_assertion_is_proof", json!(true)), ("current_exact_recovery_consent_required", json!(false)), ("atomic_exact_original_release_required", json!(false)),