commit af36dd34fbc12bd56d20dcb938ff581b1699829e parent c36c993cf8b9eefefbf13c57dac0bf58975ff4cd Author: triesap <tyson@radroots.org> Date: Mon, 26 Oct 2026 15:55:38 +0000 execution: own ordinary stock acceptance through installation - Compose exact original T0, T1, scoped signing, retained S and T2. - Install peer evidence before self work and preserve original replay policy. - Retain obtained artifacts before fallible conversion and block new issuance. - Verify real SQLite faults, caller loss, recovery, portable builds and APIs. Diffstat:
25 files changed, 2715 insertions(+), 7 deletions(-)
diff --git a/contracts/api_baselines/radroots.txt b/contracts/api_baselines/radroots.txt @@ -36,6 +36,7 @@ pub const fn radroots::client::Client::inbox(&self) -> radroots::inbox::Inbox<'_ pub const fn radroots::client::Client::listings(&self) -> radroots::listings::Listings<'_> pub async fn radroots::client::Client::open(radroots::client::NativeConfig) -> radroots_execution::Result<Self> pub fn radroots::client::Client::operations(&self, &radroots_execution::workspace::WorkspaceSession) -> radroots::operations::Operations<'_> +pub fn radroots::client::Client::orders(&self, &radroots_execution::workspace::WorkspaceSession) -> radroots::orders::Orders<'_> pub fn radroots::client::Client::preview() -> Self pub fn radroots::client::Client::signer_session(&self) -> core::option::Option<radroots_execution::session::signer::SignerSession> pub async fn radroots::client::Client::start(&self, radroots_execution::session::StartMode) -> radroots_execution::Result<radroots::client::SessionStatus> @@ -152,6 +153,16 @@ pub async fn radroots::operations::Operations<'a>::get(&self, radroots_domain::i pub async fn radroots::operations::Operations<'a>::get_matching(&self, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>) -> radroots_execution::Result<core::option::Option<radroots_execution::receipt::OperationStatus>> pub async fn radroots::operations::Operations<'a>::preparation_abort(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<core::option::Option<radroots_storage::inventory::abort::StockAbortReceipt>> pub async fn radroots::operations::Operations<'a>::resume(&self, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>) -> radroots_execution::Result<radroots_execution::receipt::OperationStatus> +pub mod radroots::orders +pub use radroots::orders::AcceptOrderInput +pub use radroots::orders::AcceptanceRecipient +pub use radroots::orders::AcceptanceStatus +pub use radroots::orders::InstalledAcceptance +pub struct radroots::orders::Orders<'a> +impl<'a> radroots::orders::Orders<'a> +pub async fn radroots::orders::Orders<'a>::accept(&self, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_protocol::command::order_acceptance::AcceptOrderInput) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> +pub async fn radroots::orders::Orders<'a>::acceptance_status(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> +pub async fn radroots::orders::Orders<'a>::resume_acceptance(&self, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> pub mod radroots::signing pub use radroots::signing::ArtifactRole pub use radroots::signing::AuthorizationHeader @@ -256,6 +267,7 @@ pub const fn radroots::client::Client::inbox(&self) -> radroots::inbox::Inbox<'_ pub const fn radroots::client::Client::listings(&self) -> radroots::listings::Listings<'_> pub async fn radroots::client::Client::open(radroots::client::NativeConfig) -> radroots_execution::Result<Self> pub fn radroots::client::Client::operations(&self, &radroots_execution::workspace::WorkspaceSession) -> radroots::operations::Operations<'_> +pub fn radroots::client::Client::orders(&self, &radroots_execution::workspace::WorkspaceSession) -> radroots::orders::Orders<'_> pub fn radroots::client::Client::preview() -> Self pub fn radroots::client::Client::signer_session(&self) -> core::option::Option<radroots_execution::session::signer::SignerSession> pub async fn radroots::client::Client::start(&self, radroots_execution::session::StartMode) -> radroots_execution::Result<radroots::client::SessionStatus> diff --git a/contracts/api_baselines/radroots_execution.txt b/contracts/api_baselines/radroots_execution.txt @@ -21,6 +21,64 @@ pub fn radroots_execution::session::command::CommandIo::seal_time(&self, radroot pub fn radroots_execution::session::command::CommandIo::targets(&self, &radroots_protocol::nip59::routes::CapturedDmRoute) -> core::result::Result<radroots_transport::target::TargetSet, radroots_storage::command::OperationError> pub fn radroots_execution::session::command::capture_dm_route<'a>(radroots_identity::key::PublicKey, impl core::iter::traits::collect::IntoIterator<Item = &'a str>, &radroots_transport::target::TargetSet) -> core::result::Result<radroots_protocol::nip59::routes::CapturedDmRoute, radroots_storage::command::OperationError> pub fn radroots_execution::session::command::selected_dm_targets(&radroots_protocol::nip59::routes::CapturedDmRoute, &radroots_transport::target::TargetSet) -> core::result::Result<radroots_transport::target::TargetSet, radroots_storage::command::OperationError> +pub mod radroots_execution::session::commerce +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::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 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 +impl core::fmt::Debug for radroots_execution::session::commerce::AcceptanceClaim +pub fn radroots_execution::session::commerce::AcceptanceClaim::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +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::recipient: radroots_identity::key::PublicKey +pub struct radroots_execution::session::commerce::AcceptanceSelection +pub radroots_execution::session::commerce::AcceptanceSelection::binding: radroots_storage::workspace::WorkspaceBinding +pub radroots_execution::session::commerce::AcceptanceSelection::digest: radroots_domain::identifier::CommandDigest +pub radroots_execution::session::commerce::AcceptanceSelection::minimum: radroots_storage::inventory::InventoryCheckpointRef +pub radroots_execution::session::commerce::AcceptanceSelection::operation: radroots_domain::identifier::OperationId +pub struct radroots_execution::session::commerce::AcceptanceStatus +impl radroots_execution::session::commerce::AcceptanceStatus +pub const fn radroots_execution::session::commerce::AcceptanceStatus::aborted(&self) -> bool +pub const fn radroots_execution::session::commerce::AcceptanceStatus::attempt(&self) -> radroots_storage::command::CommitAttempt +pub const fn radroots_execution::session::commerce::AcceptanceStatus::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub const fn radroots_execution::session::commerce::AcceptanceStatus::installation(&self) -> core::option::Option<radroots_execution::session::commerce::InstalledAcceptance> +pub const fn radroots_execution::session::commerce::AcceptanceStatus::plan_bound(&self) -> bool +pub const fn radroots_execution::session::commerce::AcceptanceStatus::recipients(&self) -> &[radroots_execution::session::commerce::AcceptanceRecipient; 2] +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::InstalledAcceptance +pub radroots_execution::session::commerce::InstalledAcceptance::attempt: radroots_storage::command::CommitAttempt +pub radroots_execution::session::commerce::InstalledAcceptance::checkpoint: radroots_storage::inventory::InventoryCheckpointRef +pub radroots_execution::session::commerce::InstalledAcceptance::order: radroots_domain::identifier::OrderId +pub radroots_execution::session::commerce::InstalledAcceptance::record: radroots_domain::identifier::RecordId +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 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 +pub fn radroots_execution::session::commerce::AcceptanceSnapshot::installation(&self) -> core::option::Option<radroots_execution::session::commerce::InstalledAcceptance> +pub fn radroots_execution::session::commerce::AcceptanceSnapshot::plan(&self) -> core::option::Option<&radroots_protocol::commerce::signing_plan::CommerceSigningPlan> +pub fn radroots_execution::session::commerce::AcceptanceSnapshot::preparation(&self) -> &radroots_storage::inventory::acceptance::StockAcceptanceReceipt +pub fn radroots_execution::session::commerce::AcceptanceSnapshot::recipients(&self) -> [radroots_execution::session::commerce::AcceptanceRecipient; 2] +pub trait radroots_execution::session::commerce::AcceptanceStore: radroots_execution::session::HostBound +pub fn radroots_execution::session::commerce::AcceptanceStore::bind<'a>(&'a self, radroots_execution::session::commerce::AcceptanceSelection, radroots_signing::commerce::VerifiedCommerceSigningPlan, &'a radroots_storage::workspace::AttachmentProof) -> radroots_execution::session::HostFuture<'a, core::result::Result<radroots_execution::session::commerce::AcceptancePlanOutcome, radroots_storage::command::OperationError>> +pub fn radroots_execution::session::commerce::AcceptanceStore::claim<'a>(&'a self, radroots_execution::session::commerce::AcceptanceSelection, radroots_identity::key::PublicKey, &'a radroots_storage::workspace::AttachmentProof) -> radroots_execution::session::HostFuture<'a, core::result::Result<radroots_execution::session::commerce::AcceptanceClaimOutcome, radroots_storage::command::OperationError>> +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 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<()> @@ -47,6 +105,10 @@ pub async fn radroots_execution::session::ClientSession<H>::stock_option_mapping pub async fn radroots_execution::session::ClientSession<H>::stock_pool(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId) -> radroots_execution::Result<core::option::Option<radroots_domain::stock::PoolView>> pub async fn radroots_execution::session::ClientSession<H>::stock_preparation_abort(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<core::option::Option<radroots_storage::inventory::abort::StockAbortReceipt>> impl<H: radroots_execution::session::SessionHost + 'static> radroots_execution::session::ClientSession<H> +pub async fn radroots_execution::session::ClientSession<H>::accept_stock_order(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, alloc::sync::Arc<dyn radroots_execution::session::commerce::AcceptanceStore>, &radroots_execution::workspace::WorkspaceSession, radroots_execution::workspace::CommandContext, radroots_storage::inventory::InventoryCheckpointRef, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_protocol::command::order_acceptance::AcceptOrderInput) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> +pub async fn radroots_execution::session::ClientSession<H>::resume_stock_acceptance(&self, alloc::sync::Arc<dyn radroots_storage::inventory::InventoryStore>, alloc::sync::Arc<dyn radroots_execution::session::commerce::AcceptanceStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> +pub async fn radroots_execution::session::ClientSession<H>::stock_acceptance_status(&self, alloc::sync::Arc<dyn radroots_execution::session::commerce::AcceptanceStore>, &radroots_execution::workspace::WorkspaceSession, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> radroots_execution::Result<radroots_execution::session::commerce::AcceptanceStatus> +impl<H: radroots_execution::session::SessionHost + 'static> radroots_execution::session::ClientSession<H> pub async fn radroots_execution::session::ClientSession<H>::inquire(&self, alloc::sync::Arc<dyn radroots_storage::command::OperationJournal>, radroots_execution::workspace::CommandContext, radroots_protocol::command::InquireInput) -> radroots_execution::Result<radroots_execution::OperationReceipt<radroots_domain::message::ChatMessage>> pub async fn radroots_execution::session::ClientSession<H>::publish_listing(&self, alloc::sync::Arc<dyn radroots_storage::command::OperationJournal>, radroots_execution::workspace::CommandContext, radroots_protocol::listing::PublishInput) -> radroots_execution::Result<radroots_execution::OperationReceipt<radroots_domain::listing::view::Listing>> pub async fn radroots_execution::session::ClientSession<H>::resume_command(&self, alloc::sync::Arc<dyn radroots_storage::command::OperationJournal>, &radroots_execution::workspace::WorkspaceSession, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>) -> radroots_execution::Result<radroots_execution::OperationStatus> diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -241,6 +241,14 @@ "source_carrier_max_bytes": 65536, "source_chunk_max_bytes": 16384, "signing_plan_binding": { + "ordinary_acceptance_owner": "radroots_execution.CommandRuntime", + "ordinary_acceptance_facade": "radroots.Orders.accept", + "ordinary_peer_installed_before_self_work": true, + "ordinary_accepted_task_survives_observer_loss": true, + "ordinary_obtained_owned_before_descriptor_conversion": true, + "ordinary_existing_claim_grants_first_dispatch": false, + "ordinary_replay_requires_original_policy_and_current_permit": true, + "ordinary_acceptance_implies_delivery": false, "crypto_verifier_owner": "radroots_signing.commerce", "scoped_crypto_verification": "SignerSession.verify_commerce_plan", "predecessor_nostr_verifier_alias": false, diff --git a/crates/execution/README.md b/crates/execution/README.md @@ -206,3 +206,24 @@ the existing single-call capacity. No legacy or first-signing method is invoked. The shared Signing proof preserves original bytes and deadline without granting T1 or stock authority. The composing executor still owns the complete task and subsequent durable boundaries after caller cancellation. + +`ClientSession::accept_stock_order` owns captured acceptance through actual T0, +complete original peer/self route and encryption checks, T1, confirmed claims, +exact scoped signing, retained S and initial T2. The shared `CommandRuntime` +contains this algorithm; `session::commerce::AcceptanceStore` supplies typed +target transactions and authenticated read-only snapshots. Host adapters select +no new business inputs or policy. Native facade views use the same configured +owner as inventory, with no second database or executor. + +The peer commitment runs first and confirmed peer S installs the agreement +before self-history work. Missing IO or signing leaves explicit pending facts. +`resume_stock_acceptance` uses only original inputs; existing non-replayable +claims never obtain a first-dispatch permit, and qualified local recovery needs +both retained policy and a current concrete permit. Obtained bytes enter the +retained evidence owner before persistence. Verified signer bytes enter that +owner before fallible request conversion; conversion refusal retains exact bytes, +credentials and the original byte lease. Accepted tasks outlive caller waits, +and close retains callback roots through settlement and durable capture. Query +facts keep preparation, recipient evidence, installation and actual abort +separate. This path performs no outer wrapping, relay publication, stock release +or proof of original nonissuance; full commerce/accounting closure remains open. diff --git a/crates/execution/src/session/client.rs b/crates/execution/src/session/client.rs @@ -14,6 +14,10 @@ mod commands; #[path = "client_inventory.rs"] mod inventory; +#[cfg(feature = "workspace_session")] +#[path = "client_commerce.rs"] +mod commerce; + struct Resources<H> { host: H, signer: Shared<Mutex<Option<SignerSession>>>, diff --git a/crates/execution/src/session/client_commerce.rs b/crates/execution/src/session/client_commerce.rs @@ -0,0 +1,256 @@ +//! Client-owned acceptance tasks; caller observation is not execution ownership. +use super::{ClientSession, SessionHost, Shared}; +use crate::{ + Error, OperationContext, + session::{ + HostBound, + command::{RunMode, SigningResources}, + commerce::*, + }, + workspace::{CommandContext, WorkspaceSession}, +}; +use alloc::boxed::Box; +use radroots_domain::{CommandDigest, OperationId}; +use radroots_protocol::command::{AcceptOrderInput, CapturedOrderAcceptance}; +use radroots_storage::{ + command::OperationError, + inventory::{ + InventoryCheckpointRef, InventoryStore, StockAcceptanceOutcome, StockAcceptanceRequest, + }, + workspace::{ + WorkspaceBinding, + seller_stock::{StockListingCheckpointRef, StockSourceCheckpointRef}, + }, +}; + +impl<H: SessionHost + 'static> ClientSession<H> { + /// Owns the original captured acceptance through T0/T1/S and initial T2. + /// The returned independent facts do not claim relay delivery or complete + /// self history. Missing IO leaves actual preparation pending without signing. + #[allow(clippy::too_many_arguments)] + pub async fn accept_stock_order( + &self, + inventory: Shared<dyn InventoryStore>, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + context: CommandContext, + minimum: InventoryCheckpointRef, + sources: StockSourceCheckpointRef, + listings: StockListingCheckpointRef, + input: AcceptOrderInput, + ) -> crate::Result<AcceptanceStatus> { + let operation = context.data().operation_id(); + if !scope.owns_context(&context) { + return Err(Error::operation( + OperationError::Unauthorized, + OperationContext::proposed(Some(operation)), + )); + } + self.submit_acceptance( + inventory, + store, + scope, + operation, + RunMode::Command, + move |binding| { + let command = CapturedOrderAcceptance::new(context.data().clone(), input) + .map_err(|_| OperationError::InvalidCommand)?; + let digest = command.digest(); + let request = StockAcceptanceRequest::capture( + binding.clone(), + minimum, + sources, + listings, + &command, + )?; + Ok(( + AcceptanceSelection { + binding, + minimum, + operation, + digest, + }, + Some(request), + )) + }, + ) + .await + } + /// Resumes only original retained inputs. Non-replayable existing claims + /// remain unknown; a qualified original local replay requires its actual + /// current host permit and original deadline. This never releases stock. + #[allow(clippy::too_many_arguments)] + pub async fn resume_stock_acceptance( + &self, + inventory: Shared<dyn InventoryStore>, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + ) -> crate::Result<AcceptanceStatus> { + self.submit_acceptance( + inventory, + store, + scope, + operation, + RunMode::Resume, + move |binding| { + Ok(( + AcceptanceSelection { + binding, + minimum, + operation, + digest, + }, + None, + )) + }, + ) + .await + } + /// Reads original stock acceptance facts without signing or replaying work. + pub async fn stock_acceptance_status( + &self, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + ) -> crate::Result<AcceptanceStatus> { + self.run_stock( + scope, + OperationContext::retained(operation), + move |binding, proof| { + Box::pin(async move { + let selection = AcceptanceSelection { + binding, + minimum, + operation, + digest, + }; + let view = store.snapshot(selection.clone(), &proof).await?; + crate::session::commerce::observe(&selection, view.as_ref()) + }) + }, + ) + .await + } + async fn submit_acceptance( + &self, + inventory: Shared<dyn InventoryStore>, + store: Shared<dyn AcceptanceStore>, + scope: &WorkspaceSession, + operation: OperationId, + mode: RunMode, + capture: impl FnOnce( + WorkspaceBinding, + ) -> Result< + (AcceptanceSelection, Option<StockAcceptanceRequest>), + OperationError, + >, + ) -> crate::Result<AcceptanceStatus> { + let proposed = OperationContext::proposed(Some(operation)); + if matches!(&mode, RunMode::Command) { + self.stock_captures + .ensure_ready() + .map_err(|e| Error::operation(e, proposed))?; + } + let permit = self.session.admit().map_err(|e| e.with_context(proposed))?; + let budget = self + .task_budget + .reserve() + .map_err(|e| e.with_context(proposed))?; + { + let scopes = self + .workspaces + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + if !scopes.iter().any(|v| v.same_scope(scope)) { + return Err(Error::operation(OperationError::Unauthorized, proposed)); + } + } + let host = self + .task_host + .as_ref() + .ok_or_else(|| Error::operation(OperationError::UnsupportedOperation, proposed))?; + let (binding, proof) = scope + .captured_input() + .map_err(|e| Error::operation(e.into(), proposed))?; + let (selection, request) = capture(binding).map_err(|e| Error::operation(e, proposed))?; + let runtime = self.commands.clone(); + let resources = SigningResources { + signer: self.signer_session(), + lease: Shared::new((permit, budget)) as Shared<dyn HostBound>, + stock_captures: self.stock_captures.clone(), + }; + let (reply, observed) = futures::channel::oneshot::channel(); + host.submit(Box::pin(async move { + let result = async { + if matches!(&mode, RunMode::Resume) { + resources.stock_captures.drain().await?; + } else { + resources + .stock_captures + .ensure_ready() + .map_err(|e| Error::operation(e, proposed))?; + } + if let Some(request) = request { + let credential = proof + .with_secret(|bytes| { + radroots_storage::workspace::AttachmentProof::from_protected_input( + bytes, + ) + }) + .map_err(|e| Error::operation(e.into(), proposed))?; + match inventory + .prepare_stock_acceptance(request, credential) + .await + .map_err(|e| Error::operation(e, proposed))? + { + StockAcceptanceOutcome::Unknown(_) => { + return Err(Error::admission_uncertain(operation)); + } + StockAcceptanceOutcome::Prepared(value) + if value.attempt().workspace_id() + == selection.binding.input().workspace_id() + && value.attempt().operation_id() == operation + && value.attempt().command_digest() == selection.digest + && value.attempt().transaction_id().is_some() => {} + StockAcceptanceOutcome::Aborted(value) + if value.attempt().workspace_id() + == selection.binding.input().workspace_id() + && value.attempt().operation_id() == operation + && value.attempt().command_digest() == selection.digest + && value.attempt().transaction_id().is_some() => {} + _ => { + return Err(Error::operation( + OperationError::RecoveryRequired, + OperationContext::admission_unknown(operation), + )); + } + } + } + if let Some(runtime) = runtime { + runtime + .run_acceptance(store, inventory, selection, &proof, resources, mode) + .await + } else { + let retained = OperationContext::retained(operation); + let view = store + .snapshot(selection.clone(), &proof) + .await + .map_err(|e| Error::operation(e, retained))?; + crate::session::commerce::observe(&selection, view.as_ref()) + .map_err(|e| Error::operation(e, retained)) + } + } + .await; + let _ = reply.send(result); + })) + .map_err(|e| e.with_context(proposed))?; + observed + .await + .unwrap_or_else(|_| Err(Error::admission_uncertain(operation))) + } +} diff --git a/crates/execution/src/session/client_inventory.rs b/crates/execution/src/session/client_inventory.rs @@ -339,7 +339,7 @@ impl<H: SessionHost + 'static> ClientSession<H> { .await } - async fn run_stock<T: HostBound + 'static>( + pub(super) async fn run_stock<T: HostBound + 'static>( &self, scope: &WorkspaceSession, proposed: OperationContext, diff --git a/crates/execution/src/session/command.rs b/crates/execution/src/session/command.rs @@ -93,7 +93,7 @@ struct PendingObservation { /// Shared workflow and obtained-material owner. Its lifecycle host must call /// `drain` before releasing work permits, callbacks or protected storage. pub struct CommandRuntime { - io: Shared<dyn CommandIo>, + pub(super) io: Shared<dyn CommandIo>, pending: Mutex<Vec<Shared<PendingCapture>>>, observations: Mutex<Vec<Shared<PendingObservation>>>, draining: futures::lock::Mutex<()>, diff --git a/crates/execution/src/session/commerce.rs b/crates/execution/src/session/commerce.rs @@ -0,0 +1,222 @@ +//! Shared acceptance orchestration and typed host transaction boundaries. +//! Host reports are a qualification boundary, never caller-created authority. +use super::{HostBound, HostFuture}; +use alloc::boxed::Box; +use core::fmt; +use radroots_domain::{CommandDigest, OperationId, OrderId, PublicKey, RecordId, SigningAttemptId}; +use radroots_protocol::commerce::CommerceSigningPlan; +use radroots_signing::{ + commerce::VerifiedCommerceSigningPlan, + issuance::{ExactRecoveryRequest, IntentBinding, SigningIntent}, + provider::ProviderCall, + request::CancellationSignal, +}; +use radroots_storage::{ + command::{CommitAttempt, OperationError}, + inventory::{InventoryCheckpointRef, StockAcceptanceReceipt, StockEvidenceReceipt}, + workspace::{AttachmentProof, WorkspaceBinding}, +}; + +#[path = "commerce_run.rs"] +mod run; +pub(crate) use run::observe; + +/// Original operation selectors and independently retained minimum; no authority. +#[derive(Clone)] +pub struct AcceptanceSelection { + /// Exact selected authenticated attachment descriptor. + pub binding: WorkspaceBinding, + /// Independently retained protected inventory minimum. + pub minimum: InventoryCheckpointRef, + /// Original full-width operation identity. + pub operation: OperationId, + /// Original captured command commitment. + pub digest: CommandDigest, +} + +/// Original durable claim metadata, without a first-dispatch or replay permit. +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct AcceptanceClaim { + /// Protected store claim identity. + pub id: SigningAttemptId, + /// Exact original event, recipient, command and deadline commitment. + pub binding: IntentBinding, +} +impl fmt::Debug for AcceptanceClaim { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("AcceptanceClaim(<redacted>)") + } +} + +/// One recipient's independent actual retained signing observations. +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct AcceptanceRecipient { + /// Exact original participant. + pub recipient: PublicKey, + /// Original claim, if durably observed; never permission to sign again. + pub claim: Option<AcceptanceClaim>, + /// First authenticated original encoding, if durably observed. + pub evidence: Option<StockEvidenceReceipt>, +} + +/// Actual initial agreement installation, independent of self-copy and delivery. +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct InstalledAcceptance { + /// Original confirmed installation transaction. + pub attempt: CommitAttempt, + /// Installed order identity. + pub order: OrderId, + /// Installed original commitment record. + pub record: RecordId, + /// Confirmed protected checkpoint. + pub checkpoint: InventoryCheckpointRef, +} +impl fmt::Debug for InstalledAcceptance { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("InstalledAcceptance(<redacted>)") + } +} + +/// Read-only authenticated native/browser snapshot retained by its target host. +/// Implementations expose original facts, not fresh allocation or signing policy. +pub trait AcceptanceSnapshot: HostBound { + /// Actual original T0 and its unchanged rumor/window. + fn preparation(&self) -> &StockAcceptanceReceipt; + /// Complete original T1, if present. + fn plan(&self) -> Option<&CommerceSigningPlan>; + /// Current authenticated protected checkpoint. + fn checkpoint(&self) -> InventoryCheckpointRef; + /// Complete original bilateral set, in canonical participant order. + fn recipients(&self) -> [AcceptanceRecipient; 2]; + /// Actual matching installation, if present. + fn installation(&self) -> Option<InstalledAcceptance>; + /// Whether an actual original proven-unissued abort was observed. + 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>; +} + +/// Actual host completion of T1; an unknown commit must be queried, not repeated +/// as a new preparation or signature. +pub enum AcceptancePlanOutcome { + /// The exact original complete plan is durably bound. + Bound(CommitAttempt), + /// Original transaction completion remains uncertain. + Unknown(CommitAttempt), +} +/// Per-recipient host claim results, without optimistic existing-claim replay. +pub enum AcceptanceClaimOutcome { + /// Fresh confirmed single-use first-dispatch permit. + Fresh(Box<dyn AcceptanceDispatch>), + /// Original claim exists and provides no fresh permit. + Existing(AcceptanceClaim), + /// Original claim transaction completion remains uncertain. + Unknown(CommitAttempt), +} +/// Actual initial T2 result; a report never claims wrapping or relay delivery. +pub enum AcceptanceInstallationOutcome { + /// Original matching agreement and recipient work are installed. + Installed(Box<InstalledAcceptance>), + /// Original installation transaction completion remains uncertain. + Unknown(CommitAttempt), +} + +/// Mechanical target transactions for the shared concrete acceptance algorithm. +/// Implementations enforce protected identity, CAS, consent and exact transaction +/// completion. They do not choose business inputs, invoke signers or run a +/// replacement application workflow. The ordinary facade selects the same owner +/// as its InventoryStore; custom hosts require their own executed qualification. +pub trait AcceptanceStore: HostBound { + /// Reads original T0/T1, independent recipient S and initial T2 coherently. + fn snapshot<'a>( + &'a self, + selection: AcceptanceSelection, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<Box<dyn AcceptanceSnapshot>, OperationError>>; + /// Binds a shared cryptographically qualified exact plan to original T0. + fn bind<'a>( + &'a self, + selection: AcceptanceSelection, + plan: VerifiedCommerceSigningPlan, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<AcceptancePlanOutcome, OperationError>>; + /// Commits and observes the exact original recipient's first claim. + fn claim<'a>( + &'a self, + selection: AcceptanceSelection, + recipient: PublicKey, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<AcceptanceClaimOutcome, OperationError>>; + /// Explicit original exact replay authorization; unsupported hosts refuse. + /// Refusal proves nothing about the original invocation's issuance. + fn exact_replay<'a>( + &'a self, + _selection: AcceptanceSelection, + _recipient: PublicKey, + _call: ProviderCall, + _proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<(ExactRecoveryRequest, AcceptanceClaim), OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Installs only the original agreement backed by actually retained peer S. + fn install<'a>( + &'a self, + selection: AcceptanceSelection, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<AcceptanceInstallationOutcome, OperationError>>; +} + +/// Owned original operation facts. No wait, signature or relay outcome is +/// collapsed into business success; this report cannot dispatch or release stock. +pub struct AcceptanceStatus { + pub(crate) attempt: CommitAttempt, + pub(crate) record: RecordId, + pub(crate) checkpoint: InventoryCheckpointRef, + pub(crate) recipients: [AcceptanceRecipient; 2], + pub(crate) plan_bound: bool, + pub(crate) installation: Option<InstalledAcceptance>, + pub(crate) aborted: bool, +} +impl AcceptanceStatus { + /// Original confirmed T0 anchor. + pub const fn attempt(&self) -> CommitAttempt { + self.attempt + } + /// Original immutable commitment record. + pub const fn record_id(&self) -> RecordId { + self.record + } + /// Current authenticated observation checkpoint. + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } + /// Independent peer/self original signing observations. + pub const fn recipients(&self) -> &[AcceptanceRecipient; 2] { + &self.recipients + } + /// Whether complete original T1 was actually observed. + pub const fn plan_bound(&self) -> bool { + self.plan_bound + } + /// Actual original T2, independently of self-copy or relay delivery. + pub const fn installation(&self) -> Option<InstalledAcceptance> { + self.installation + } + /// Actual original abort observation, never inferred from absent evidence. + pub const fn aborted(&self) -> bool { + self.aborted + } +} +impl fmt::Debug for AcceptanceStatus { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("AcceptanceStatus(<redacted>)") + } +} diff --git a/crates/execution/src/session/commerce_run.rs b/crates/execution/src/session/commerce_run.rs @@ -0,0 +1,454 @@ +//! One shared T1/S/T2 algorithm; target hosts implement transactions only. +use super::*; +use crate::{ + Error, OperationContext, + session::{ + Shared, SignerSession, + command::{CommandRuntime, RunMode, SigningResources}, + }, +}; +use alloc::vec::Vec; +use core::num::NonZeroU64; +use radroots_domain::UnixSeconds; +use radroots_protocol::{ + commerce::{CommerceSeal, EncodedCommerceRumor}, + intent::SigningReplay, +}; +use radroots_signing::{ + issuance::{ExactRecoveryCapability, ExactRecoveryKind, OutcomeKind, SignedArtifact}, + provider::PrivateText, + recovery::ReplayCapability, +}; +use radroots_storage::inventory::{InventoryStore, StockEvidenceOutcome}; + +fn same(attempt: CommitAttempt, selection: &AcceptanceSelection) -> bool { + attempt.workspace_id() == selection.binding.input().workspace_id() + && attempt.operation_id() == selection.operation + && attempt.command_digest() == selection.digest +} +pub(crate) fn observe( + selection: &AcceptanceSelection, + snapshot: &dyn AcceptanceSnapshot, +) -> Result<AcceptanceStatus, OperationError> { + let original = snapshot.preparation(); + let recipients = snapshot.recipients(); + if !same(original.attempt(), selection) + || original.attempt().transaction_id().is_none() + || recipients + .iter() + .map(|v| v.recipient) + .ne(original.rumor().recipients().iter().copied()) + { + return Err(OperationError::RecoveryRequired); + } + if let Some(plan) = snapshot.plan() { + CommerceSigningPlan::parse( + selection.operation, + selection.digest, + original.rumor(), + plan.protected_wire(), + ) + .map_err(|_| OperationError::RecoveryRequired)?; + } else if recipients + .iter() + .any(|v| v.claim.is_some() || v.evidence.is_some()) + { + return Err(OperationError::RecoveryRequired); + } + for recipient in &recipients { + if let Some(claim) = recipient.claim { + let plan = snapshot.plan().ok_or(OperationError::RecoveryRequired)?; + let seal = plan + .seals() + .iter() + .find(|v| v.recipient() == recipient.recipient) + .ok_or(OperationError::RecoveryRequired)?; + if claim.binding + != SigningIntent::from_commerce_seal(seal, call(original)?) + .map_err(|_| OperationError::RecoveryRequired)? + .binding() + { + return Err(OperationError::RecoveryRequired); + } + } + if let Some(evidence) = recipient.evidence + && (!same(evidence.attempt(), selection) + || evidence.attempt().transaction_id().is_none() + || evidence.recipient() != recipient.recipient + || recipient + .claim + .is_none_or(|v| v.id != evidence.signing_attempt_id())) + { + return Err(OperationError::RecoveryRequired); + } + } + let installation = snapshot.installation(); + if snapshot.aborted() + && recipients + .iter() + .any(|v| v.claim.is_some() || v.evidence.is_some()) + { + return Err(OperationError::RecoveryRequired); + } + if let Some(installed) = installation { + let peer = recipients + .iter() + .find(|v| v.recipient != original.rumor().author()) + .ok_or(OperationError::RecoveryRequired)?; + if !same(installed.attempt, selection) + || installed.attempt.transaction_id().is_none() + || installed.order != original.order_id() + || installed.record != original.rumor().record_id() + || peer.evidence.is_none() + || snapshot.aborted() + { + return Err(OperationError::RecoveryRequired); + } + } + Ok(AcceptanceStatus { + attempt: original.attempt(), + record: original.rumor().record_id(), + checkpoint: snapshot.checkpoint(), + recipients, + plan_bound: snapshot.plan().is_some(), + installation, + aborted: snapshot.aborted(), + }) +} +fn call(original: &StockAcceptanceReceipt) -> Result<ProviderCall, OperationError> { + let deadline = original + .first_issue_deadline() + .get() + .checked_mul(1000) + .and_then(NonZeroU64::new) + .ok_or(OperationError::RecoveryRequired)?; + Ok(ProviderCall::new( + original.rumor().author(), + deadline, + CancellationSignal::new(), + )) +} +fn copy(proof: &AttachmentProof) -> Result<AttachmentProof, OperationError> { + proof + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .map_err(Into::into) +} +impl CommandRuntime { + pub(in crate::session) async fn run_acceptance( + &self, + store: Shared<dyn AcceptanceStore>, + inventory: Shared<dyn InventoryStore>, + mut selection: AcceptanceSelection, + proof: &AttachmentProof, + resources: SigningResources, + mode: RunMode, + ) -> crate::Result<AcceptanceStatus> { + let retained = OperationContext::retained(selection.operation); + let fail = |e| Error::operation(e, retained); + let mut snapshot = store + .snapshot(selection.clone(), proof) + .await + .map_err(fail)?; + let mut status = observe(&selection, snapshot.as_ref()).map_err(fail)?; + if !snapshot.aborted() + && snapshot.installation().is_none() + && snapshot.recipients().iter().any(|v| { + v.recipient != snapshot.preparation().rumor().author() && v.evidence.is_some() + }) + { + selection.minimum = snapshot.checkpoint(); + match store + .install(selection.clone(), proof) + .await + .map_err(fail)? + { + AcceptanceInstallationOutcome::Installed(value) + if same(value.attempt, &selection) + && value.attempt.transaction_id().is_some() => {} + _ => return Err(fail(OperationError::RecoveryRequired)), + } + snapshot = store + .snapshot(selection.clone(), proof) + .await + .map_err(fail)?; + status = observe(&selection, snapshot.as_ref()).map_err(fail)?; + } + if snapshot.aborted() || !self.io.enabled() { + return Ok(status); + } + self.drain().await.map_err(fail)?; + resources.stock_captures.ensure_ready().map_err(fail)?; + let Some(signer) = resources.signer.as_ref() else { + return Ok(status); + }; + if snapshot.plan().is_none() { + let plan = self + .acceptance_plan(snapshot.preparation(), signer) + .await + .map_err(fail)?; + selection.minimum = snapshot.checkpoint(); + match store + .bind(selection.clone(), plan, proof) + .await + .map_err(fail)? + { + AcceptancePlanOutcome::Bound(anchor) + if same(anchor, &selection) && anchor.transaction_id().is_some() => {} + _ => return Err(fail(OperationError::RecoveryRequired)), + } + } + let author = snapshot.preparation().rumor().author(); + let peer = *snapshot + .preparation() + .rumor() + .recipients() + .iter() + .find(|v| **v != author) + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + drop(snapshot); + // A peer commitment is installed before self-history work can fail. + for recipient in [peer, author] { + let current = store + .snapshot(selection.clone(), proof) + .await + .map_err(fail)?; + observe(&selection, current.as_ref()).map_err(fail)?; + if current.aborted() { + return observe(&selection, current.as_ref()).map_err(fail); + } + selection.minimum = current.checkpoint(); + let facts = current + .recipients() + .into_iter() + .find(|v| v.recipient == recipient) + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + if facts.evidence.is_none() { + resources.stock_captures.ensure_ready().map_err(fail)?; + let plan = current + .plan() + .ok_or_else(|| fail(OperationError::RecoveryRequired))?; + if facts.claim.is_some() + && (!matches!(&mode, RunMode::Resume) + || plan.replay() != SigningReplay::LocalReplaySafe) + { + continue; + } + if facts.claim.is_none() + && self.io.now().map_err(fail)? >= current.preparation().first_issue_deadline() + { + continue; + } + // Recheck every originally selected target and the actual scoped + // provider before acquiring any fresh first-dispatch claim. + for route in plan.routes() { + self.io.targets(route).map_err(fail)?; + } + let original = current.preparation(); + let plan_copy = CommerceSigningPlan::parse( + selection.operation, + selection.digest, + original.rumor(), + plan.protected_wire(), + ) + .map_err(|_| fail(OperationError::RecoveryRequired))?; + signer + .verify_commerce_plan( + call(original).map_err(fail)?, + original.rumor(), + plan_copy, + ) + .await + .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 { + return Err(fail(OperationError::RecoveryRequired)); + } + match signer.recover_exact(request).await.into_parts().1 { + ExactRecoveryKind::Obtained(artifact) => Some((artifact, report)), + _ => 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)); + } + resources.stock_captures.ensure_ready().map_err(fail)?; + match signer.sign_exact(intent).await.into_parts().1 { + OutcomeKind::Obtained(artifact) => Some((artifact, report)), + _ => None, + } + } + 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 { + selection: capture_selection, + claim, + recipient, + store: inventory.clone(), + proof: capture_proof, + lease: resources.lease.clone(), + }, + artifact, + ); + if !matches!( + resources + .stock_captures + .capture_obtained(&pending) + .await + .map_err(|e| e.with_context(retained))?, + StockEvidenceOutcome::Committed(_) + ) { + return Err(fail(OperationError::RecoveryRequired)); + } + } + } + if recipient == peer { + let captured = store + .snapshot(selection.clone(), proof) + .await + .map_err(fail)?; + observe(&selection, captured.as_ref()).map_err(fail)?; + let peer_ready = captured + .recipients() + .iter() + .any(|v| v.recipient == peer && v.evidence.is_some()); + if peer_ready && captured.installation().is_none() { + selection.minimum = captured.checkpoint(); + match store + .install(selection.clone(), proof) + .await + .map_err(fail)? + { + AcceptanceInstallationOutcome::Installed(value) + if same(value.attempt, &selection) + && value.attempt.transaction_id().is_some() => {} + _ => return Err(fail(OperationError::RecoveryRequired)), + } + } + } + } + let final_view = store + .snapshot(selection.clone(), proof) + .await + .map_err(fail)?; + observe(&selection, final_view.as_ref()).map_err(fail) + } + async fn acceptance_plan( + &self, + original: &StockAcceptanceReceipt, + signer: &SignerSession, + ) -> Result<VerifiedCommerceSigningPlan, OperationError> { + let rumor: &EncodedCommerceRumor = original.rumor(); + let now: UnixSeconds = self.io.now()?; + if now < original.prepared_at() || now >= original.first_issue_deadline() { + return Err(OperationError::DeadlineExceeded); + } + let state = signer + .observe() + .await + .map_err(|_| OperationError::Unauthorized)?; + if state.identity() != rumor.author() { + return Err(OperationError::Unauthorized); + } + let replay = match state.exact_issuance() { + Some(_) if state.exact_recovery() == ExactRecoveryCapability::LocalExactReplay => { + SigningReplay::LocalReplaySafe + } + Some(ReplayCapability::NonReplayable) => SigningReplay::NonReplayable, + Some(ReplayCapability::ExactReplayByRequestId) => SigningReplay::ExactReplayByRequestId, + _ => return Err(OperationError::UnsupportedOperation), + }; + let mut routes = Vec::with_capacity(2); + for recipient in rumor.recipients() { + let route = self + .io + .route(*recipient, call(original)?.deadline_unix_ms()) + .await?; + self.io.targets(&route)?; + routes.push(route); + } + let mut seals = Vec::with_capacity(2); + for recipient in rumor.recipients() { + let plaintext = PrivateText::new(rumor.protected_wire()) + .map_err(|_| OperationError::InvalidCommand)?; + let ciphertext = signer + .encrypt_private(call(original)?, *recipient, plaintext) + .await + .map_err(|_| OperationError::Unauthorized)?; + seals.push( + CommerceSeal::new( + original.attempt().operation_id(), + original.attempt().command_digest(), + rumor, + *recipient, + self.io.seal_time(now)?, + ciphertext.as_str(), + ) + .map_err(|_| OperationError::InvalidEvidence)?, + ); + } + let plan = CommerceSigningPlan::new( + original.attempt().operation_id(), + original.attempt().command_digest(), + rumor, + seals + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + routes + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + replay, + ) + .map_err(|_| OperationError::InvalidEvidence)?; + signer + .verify_commerce_plan(call(original)?, rumor, plan) + .await + .map_err(|_| OperationError::InvalidEvidence) + } +} diff --git a/crates/execution/src/session/mod.rs b/crates/execution/src/session/mod.rs @@ -11,6 +11,9 @@ pub mod tasks; pub mod command; #[cfg(feature = "workspace_session")] +pub mod commerce; + +#[cfg(feature = "workspace_session")] mod stock_evidence; #[cfg(feature = "client_session")] diff --git a/crates/execution/src/session/stock_evidence.rs b/crates/execution/src/session/stock_evidence.rs @@ -7,6 +7,9 @@ use radroots_storage::{ workspace::AttachmentProof, }; use std::{sync::Mutex, vec::Vec}; +#[path = "stock_obtained.rs"] +mod obtained; +pub(super) use obtained::{ObtainedContext, RetainedObtained}; pub(super) struct Pending { store: Shared<dyn InventoryStore>, @@ -17,17 +20,23 @@ pub(super) struct Pending { } #[derive(Default)] pub(super) struct Owner { + unmapped: Mutex<Vec<Shared<RetainedObtained>>>, pending: Mutex<Vec<Shared<Pending>>>, serial: futures::lock::Mutex<()>, } impl Owner { pub(super) fn ensure_ready(&self) -> Result<(), OperationError> { - if self + // Hold both views together: conversion inserts pending before removing + // unmapped material, so a split observation must not miss that transfer. + let pending = self .pending .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner) - .is_empty() - { + .unwrap_or_else(std::sync::PoisonError::into_inner); + let unmapped = self + .unmapped + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + if pending.is_empty() && unmapped.is_empty() { Ok(()) } else { Err(OperationError::RecoveryRequired) @@ -141,6 +150,16 @@ impl Owner { let _serial = self.serial.lock().await; loop { let entry = self + .unmapped + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .first() + .cloned(); + let Some(entry) = entry else { break }; + self.map_obtained(&entry)?; + } + loop { + let entry = self .pending .lock() .unwrap_or_else(std::sync::PoisonError::into_inner) diff --git a/crates/execution/src/session/stock_obtained.rs b/crates/execution/src/session/stock_obtained.rs @@ -0,0 +1,100 @@ +//! Register obtained bytes before any fallible storage-descriptor conversion. +use super::*; +use crate::session::commerce::{AcceptanceClaim, AcceptanceSelection}; +use radroots_domain::PublicKey; +use radroots_signing::issuance::SignedArtifact; + +#[cfg(all(test, not(target_arch = "wasm32")))] +#[path = "stock_obtained_tests.rs"] +mod tests; + +pub(in crate::session) struct ObtainedContext { + pub selection: AcceptanceSelection, + pub claim: AcceptanceClaim, + pub recipient: PublicKey, + pub store: Shared<dyn InventoryStore>, + pub proof: AttachmentProof, + pub lease: Shared<dyn HostBound>, +} +pub(in crate::session) struct RetainedObtained { + context: ObtainedContext, + artifact: SignedArtifact, + mapped: Mutex<Option<Shared<Pending>>>, +} +impl Owner { + pub(in crate::session) fn retain_obtained( + &self, + context: ObtainedContext, + artifact: SignedArtifact, + ) -> Shared<RetainedObtained> { + let entry = Shared::new(RetainedObtained { + context, + artifact, + mapped: Mutex::new(None), + }); + self.unmapped + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .push(entry.clone()); + entry + } + pub(super) fn map_obtained( + &self, + entry: &Shared<RetainedObtained>, + ) -> crate::Result<Shared<Pending>> { + let mut mapped = entry + .mapped + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + if let Some(pending) = mapped.as_ref() { + return Ok(pending.clone()); + } + let context = &entry.context; + let error = |reason| { + Error::capture_pending( + reason, + OperationContext::retained(context.selection.operation), + ) + }; + let request = entry + .artifact + .with_json(|raw| { + StockEvidenceRequest::from_obtained_wire( + context.selection.binding.clone(), + context.selection.operation, + context.selection.digest, + context.claim.id, + context.recipient, + *context.claim.binding.digest(), + raw, + entry.artifact.observed_at_unix_ms(), + ) + }) + .map_err(error)?; + let proof = context + .proof + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .map_err(|e| error(e.into()))?; + let pending = self.retain(context.store.clone(), request, proof, context.lease.clone()); + *mapped = Some(pending.clone()); + let removed = { + let mut raw = self + .unmapped + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + raw.iter() + .position(|v| Shared::ptr_eq(v, entry)) + .map(|index| raw.remove(index)) + }; + drop(removed); + Ok(pending) + } + pub(in crate::session) async fn capture_obtained( + &self, + entry: &Shared<RetainedObtained>, + ) -> crate::Result<StockEvidenceOutcome> { + let _serial = self.serial.lock().await; + let pending = self.map_obtained(entry)?; + self.append(&pending, false).await + } +} diff --git a/crates/execution/src/session/stock_obtained_tests.rs b/crates/execution/src/session/stock_obtained_tests.rs @@ -0,0 +1,190 @@ +//! Conversion refusal must retain actual verified original bytes without IO. +use super::*; +use crate::session::commerce::{AcceptanceClaim, AcceptanceSelection}; +use alloc::vec; +use futures::executor::block_on; +use radroots_domain::{ + ActorRef, ActorRole, AuthorityRef, CheckpointDigest, CheckpointRef, CommandDigest, Coverage, + ExecutorId, Generation, GrantId, OperationId, PoolId, RouteDigest, Sequence, SigningAttemptId, + UnixSeconds, WorkspaceId, + stock::{OptionMappingKey, OptionPoolMapping, PoolView}, +}; +use radroots_protocol::{ + command::CapturedOrderAcceptance, + commerce::{self, CommerceSigningPlan, EncodedCommerceRumor}, +}; +use radroots_signing::{ + issuance::{OutcomeKind, SigningIntent, SigningOutcome}, + provider::ProviderCall, + request::CancellationSignal, +}; +use radroots_storage::{ + event::BoxFuture, + inventory::{InventoryCheckpointRef, InventoryOutcome, InventoryReceipt, InventoryRequest}, + workspace::{ + AttachmentInput, WorkspaceBinding, WorkspaceError, WorkspaceScope, WorkspaceStore, + }, +}; +use std::num::NonZeroU64; +struct NoIo; +impl WorkspaceStore for NoIo { + fn authenticate( + &self, + _: AttachmentInput, + _: AttachmentProof, + ) -> BoxFuture<'_, Result<WorkspaceBinding, WorkspaceError>> { + panic!("mapping refusal must execute no host IO") + } + fn close_workspace(&self) -> BoxFuture<'_, Result<(), WorkspaceError>> { + panic!("mapping refusal must execute no host IO") + } +} +impl InventoryStore for NoIo { + fn option_mapping( + &self, + _: WorkspaceBinding, + _: InventoryCheckpointRef, + _: OptionMappingKey, + _: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<OptionPoolMapping>, OperationError>> { + panic!("unexpected IO") + } + fn execute_inventory( + &self, + _: InventoryRequest, + _: AttachmentProof, + ) -> BoxFuture<'_, Result<InventoryOutcome, OperationError>> { + panic!("unexpected IO") + } + fn inventory_operation( + &self, + _: WorkspaceBinding, + _: InventoryCheckpointRef, + _: OperationId, + _: Option<CommandDigest>, + _: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<InventoryReceipt>, OperationError>> { + panic!("unexpected IO") + } + fn pool( + &self, + _: WorkspaceBinding, + _: InventoryCheckpointRef, + _: PoolId, + _: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<PoolView>, OperationError>> { + panic!("unexpected IO") + } +} +#[test] +fn mapping_refusal_keeps_verified_artifact_credentials_and_lease_before_any_storage_request() { + let command = CapturedOrderAcceptance::parse(include_bytes!( + "../../tests/fixtures/commerce_verification/command_wire.json" + )) + .unwrap(); + let record = commerce::decode(include_bytes!( + "../../tests/fixtures/commerce_verification/record_wire.json" + )) + .unwrap(); + let rumor = EncodedCommerceRumor::capture(record.content()).unwrap(); + let plan = CommerceSigningPlan::parse( + command.context().operation_id(), + command.digest(), + &rumor, + include_bytes!("../../tests/fixtures/commerce_verification/plan_wire.bin"), + ) + .unwrap(); + let seal = &plan.seals()[0]; + let intent = SigningIntent::from_commerce_seal( + seal, + ProviderCall::new( + rumor.author(), + NonZeroU64::new(600000).unwrap(), + CancellationSignal::new(), + ), + ) + .unwrap(); + let wire = include_str!("../../tests/fixtures/commerce_verification/seal_signed.json"); + let (_, OutcomeKind::Obtained(artifact)) = + SigningOutcome::capture(&intent, wire.into(), None).into_parts() + else { + panic!("fixture must verify as the exact original signed artifact") + }; + // A deliberately wrong non-stock descriptor forces conversion to fail. + // Neither the fake host nor this descriptor has transaction authority. + let authority = AuthorityRef::new(ExecutorId::from_bytes([2; 32]), Generation::new(1).unwrap()); + let input = AttachmentInput::new( + WorkspaceId::from_bytes([1; 32]), + authority, + rumor.author(), + "local://model", + rumor.author(), + GrantId::from_bytes([3; 32]), + CheckpointRef::new( + CheckpointDigest::from_bytes([4; 32]), + Sequence::new(0).unwrap(), + Coverage::Partial, + vec![], + ) + .unwrap(), + RouteDigest::from_bytes([5; 32]), + ) + .unwrap(); + let binding = WorkspaceBinding::from_authenticated_host( + input.clone(), + WorkspaceScope::NewSellerOutbox, + ActorRef::new( + rumor.author(), + ActorRole::Seller, + None, + Some(input.grant_id()), + ), + "device", + Sequence::new(1).unwrap(), + UnixSeconds::new(200).unwrap(), + UnixSeconds::new(100).unwrap(), + ) + .unwrap(); + let lease = Shared::new(()); + let weak = Shared::downgrade(&lease); + let context = ObtainedContext { + selection: AcceptanceSelection { + binding, + minimum: InventoryCheckpointRef::from_host_metadata( + authority, + Sequence::new(0).unwrap(), + None, + ) + .unwrap(), + operation: command.context().operation_id(), + digest: command.digest(), + }, + claim: AcceptanceClaim { + id: SigningAttemptId::from_bytes([6; 32]), + binding: intent.binding(), + }, + recipient: seal.recipient(), + store: Shared::new(NoIo), + proof: AttachmentProof::from_protected_input(&[7; 32]).unwrap(), + lease: lease.clone(), + }; + 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 + ); + drop(entry); + assert!(weak.upgrade().is_some()); + assert!(owner.ensure_ready().is_err()); + assert_eq!( + block_on(owner.drain()).unwrap_err().code(), + crate::Code::Unauthorized + ); + let retained = owner.unmapped.lock().unwrap(); + assert_eq!(retained.len(), 1); + assert_eq!(retained[0].context.proof.with_secret(|b| *b), [7; 32]); + retained[0].artifact.with_json(|raw| assert_eq!(raw, wire)); + assert!(owner.pending.lock().unwrap().is_empty()); +} diff --git a/crates/execution/tests/fixtures/commerce_verification/README.md b/crates/execution/tests/fixtures/commerce_verification/README.md @@ -10,3 +10,5 @@ The actual Nostr LocalSigner tests retain the complete original vector and quali - `command_wire.json`: SHA-256 `885ad89e2ece65a4bf670a7df6d5c25b9ca3018d0bff60634f5489b7610f058d`. - `record_wire.json`: SHA-256 `c6cae54b2d00d8675bd8694fa2eb46df8e9133220c08d1ebf71da91baaca2beb`. - `plan_wire.bin`: SHA-256 `458840ff907b5d478ce4be792b2a5e0cfb76e15a699b329624ed352894c66ee2`. + +- `seal_signed.json`: literal first `seals[].raw` from that same source, SHA-256 `839834912414e6731076b95d27b40af27911f4f9175447f31d96b92118f1adba`; used for the retained-artifact conversion-refusal case, with no store or new signing invocation. diff --git a/crates/execution/tests/fixtures/commerce_verification/seal_signed.json b/crates/execution/tests/fixtures/commerce_verification/seal_signed.json @@ -0,0 +1 @@ +{"id":"75ddd9845250c8c3fe4712731217d669dfa26500d5cfcafbfe5cc10ee12e50e4","pubkey":"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798","created_at":450,"kind":13,"tags":[],"content":"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","sig":"76b5e96745509275ef4019afa1a9ed17ad11cec692aa9037bfb899a6af212c41c171a0907facf737e67def29a63e84d53e2e9d8d01a1169e27e1d069ef4211a4"} +\ No newline at end of file diff --git a/crates/radroots/README.md b/crates/radroots/README.md @@ -122,6 +122,20 @@ These calls neither sign nor publish, and cleanup is separate from business cancellation or stopping delivery. Full commerce orchestration, qualified claimed attempt reconciliation and the final common receipt/binding surface remain open. +`client.orders(&scope).accept(context, minimum, sources, listings, input)` owns +the captured acceptance through the same native stock owner's T0/T1/S and +initial T2. Core verifies the complete original peer/self routes and ciphertexts +before signing, captures peer evidence and installs its agreement before +self-copy work. Inspect `AcceptanceStatus` for independent recipient and +installation facts. Preparation alone is pending; this path claims no wrapping +or relay delivery. `acceptance_status` reads original facts and +`resume_acceptance` explicitly continues original retained work. Existing claims +never provide a fresh signing permit. Qualified recovery requires the retained +policy, actual current host permit and original window. Caller wait loss cannot +discard accepted work or obtained material. Application migrations, full order +transitions/accounting, original negative reconciliation and final qualification +remain separate required work. + `radroots::domain` provides exact decimals and distinct order, thread, workspace, executor and operation identities. `radroots::OperationId` is the 256-bit retained identity. These values alone perform no authorization or transaction. diff --git a/crates/radroots/src/client.rs b/crates/radroots/src/client.rs @@ -1,4 +1,7 @@ //! Explicit preview/native resource opening and owned session lifecycle. +#[cfg(all(test, feature = "native", unix))] +#[path = "native_commerce_tests.rs"] +mod commerce_tests; #[cfg(any(feature = "client", feature = "native"))] use core::num::NonZeroU16; use radroots_execution::{ @@ -67,6 +70,7 @@ impl CloseReceipt { struct WorkspaceResource { journal: Shared<dyn radroots_storage::command::OperationJournal>, inventory: Shared<dyn radroots_storage::inventory::InventoryStore>, + commerce: Option<Shared<dyn radroots_execution::session::commerce::AcceptanceStore>>, } /// Explicit native public-cache opening, without participant/stock authority. @@ -101,7 +105,8 @@ impl NativeConfig { let owner = Shared::new(workspace); self.workspace = Some(WorkspaceResource { journal: owner.clone(), - inventory: owner, + inventory: owner.clone(), + commerce: Some(Shared::new(crate::native_commerce::NativeCommerce(owner))), }); self } @@ -363,6 +368,20 @@ impl Client { ) -> crate::stock::Stock<'_> { crate::stock::Stock::new(self, scope.clone()) } + + /// Selects ordinary order workflows through this client's attachment. + /// Constructing the view establishes no stock or signing permission. + pub fn orders(&self, scope: &crate::WorkspaceSession) -> crate::orders::Orders<'_> { + crate::orders::Orders::new(self, scope.clone()) + } + pub(crate) fn acceptance_store( + &self, + ) -> crate::Result<Shared<dyn radroots_execution::session::commerce::AcceptanceStore>> { + self.workspace + .as_ref() + .and_then(|v| v.commerce.clone()) + .ok_or(MISSING_WORKSPACE) + } /// Accesses private inquiry execution. Access alone performs no work. pub const fn inbox(&self) -> crate::inbox::Inbox<'_> { crate::inbox::Inbox::new(self) diff --git a/crates/radroots/src/lib.rs b/crates/radroots/src/lib.rs @@ -13,6 +13,7 @@ pub mod knowledge; pub mod listing; pub mod listings; pub mod operations; +pub mod orders; pub mod signing; pub mod stock; pub mod storage; @@ -26,6 +27,9 @@ mod native_tasks; #[cfg(all(feature = "native", not(target_arch = "wasm32")))] mod native_commands; +#[cfg(all(feature = "native", unix))] +mod native_commerce; + #[cfg(feature = "native")] pub use client::NativeConfig; pub use client::{Client, CloseReceipt, SessionStatus, StartMode}; diff --git a/crates/radroots/src/native_commerce.rs b/crates/radroots/src/native_commerce.rs @@ -0,0 +1,203 @@ +//! Mechanical views of the same selected native stock owner for Core workflows. +use radroots_domain::PublicKey; +use radroots_execution::session::{ + HostFuture, + commerce::{ + AcceptanceClaim, AcceptanceClaimOutcome, AcceptanceDispatch, AcceptanceInstallationOutcome, + AcceptancePlanOutcome, AcceptanceRecipient, AcceptanceSelection, AcceptanceSnapshot, + AcceptanceStore, InstalledAcceptance, + }, +}; +use radroots_signing::{ + host::Shared, + issuance::{ExactRecoveryRequest, SigningIntent}, + provider::ProviderCall, + request::CancellationSignal, +}; +use radroots_storage::{ + command::OperationError, + inventory::{InventoryCheckpointRef, StockAcceptanceReceipt}, + workspace::AttachmentProof, +}; +use radroots_storage_sqlite::workspace::{ + NativeWorkspace, StockClaimOutcome, StockClaimRequest, StockDispatchPermit, + StockInstallationOutcome, StockInstallationReceipt, StockInstallationRequest, + StockOperationSnapshot, StockSigningAttempt, StockSigningPlanOutcome, StockSigningPlanRequest, + StockSnapshotRequest, +}; + +pub(crate) struct NativeCommerce(pub(crate) Shared<NativeWorkspace>); +struct Snapshot(StockOperationSnapshot); +struct Dispatch(StockDispatchPermit); +fn claim(value: &StockSigningAttempt) -> AcceptanceClaim { + AcceptanceClaim { + id: value.attempt_id(), + binding: value.binding(), + } +} +fn installation(value: &StockInstallationReceipt) -> InstalledAcceptance { + InstalledAcceptance { + attempt: value.attempt(), + order: value.order_id(), + record: value.record_id(), + checkpoint: value.checkpoint(), + } +} +impl AcceptanceSnapshot for Snapshot { + fn preparation(&self) -> &StockAcceptanceReceipt { + self.0.preparation() + } + fn plan(&self) -> Option<&radroots_protocol::commerce::CommerceSigningPlan> { + self.0.signing_plan().map(|v| v.plan()) + } + fn checkpoint(&self) -> InventoryCheckpointRef { + self.0.checkpoint() + } + fn recipients(&self) -> [AcceptanceRecipient; 2] { + self.0.recipients().each_ref().map(|v| AcceptanceRecipient { + recipient: v.recipient(), + claim: v.claim().map(|c| AcceptanceClaim { + id: c.attempt_id(), + binding: c.binding(), + }), + evidence: v.first_evidence(), + }) + } + fn installation(&self) -> Option<InstalledAcceptance> { + self.0.installation().map(installation) + } + fn aborted(&self) -> bool { + self.0.aborted().is_some() + } +} +impl AcceptanceDispatch for Dispatch { + fn into_intent( + self: Box<Self>, + cancel: CancellationSignal, + ) -> Result<(SigningIntent, AcceptanceClaim), OperationError> { + let (intent, report) = self.0.into_signing_intent(cancel)?; + Ok((intent, claim(&report))) + } +} +fn select(value: AcceptanceSelection, recipient: PublicKey) -> StockClaimRequest { + StockClaimRequest::new( + value.binding, + value.minimum, + value.operation, + value.digest, + recipient, + ) +} +impl AcceptanceStore for NativeCommerce { + fn snapshot<'a>( + &'a self, + value: AcceptanceSelection, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<Box<dyn AcceptanceSnapshot>, OperationError>> { + Box::pin(async move { + let value = self + .0 + .stock_operation_snapshot( + StockSnapshotRequest::new( + value.binding, + value.minimum, + value.operation, + value.digest, + ), + proof, + ) + .await?; + Ok(Box::new(Snapshot(value)) as Box<dyn AcceptanceSnapshot>) + }) + } + fn bind<'a>( + &'a self, + value: AcceptanceSelection, + plan: radroots_signing::commerce::VerifiedCommerceSigningPlan, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<AcceptancePlanOutcome, OperationError>> { + Box::pin(async move { + match self + .0 + .bind_stock_signing_intents( + StockSigningPlanRequest::new(value.binding, value.minimum, plan)?, + proof, + ) + .await? + { + StockSigningPlanOutcome::Bound(value) => { + Ok(AcceptancePlanOutcome::Bound(value.attempt())) + } + StockSigningPlanOutcome::Unknown(value) => { + Ok(AcceptancePlanOutcome::Unknown(value)) + } + } + }) + } + fn claim<'a>( + &'a self, + value: AcceptanceSelection, + recipient: PublicKey, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<AcceptanceClaimOutcome, OperationError>> { + Box::pin(async move { + match self + .0 + .claim_stock_signing_attempt(select(value, recipient), proof) + .await? + { + StockClaimOutcome::Fresh(value) => { + Ok(AcceptanceClaimOutcome::Fresh(Box::new(Dispatch(value)))) + } + StockClaimOutcome::Existing(value) => { + Ok(AcceptanceClaimOutcome::Existing(claim(&value))) + } + StockClaimOutcome::Unknown(value) => Ok(AcceptanceClaimOutcome::Unknown(value)), + } + }) + } + fn exact_replay<'a>( + &'a self, + value: AcceptanceSelection, + recipient: PublicKey, + call: ProviderCall, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<(ExactRecoveryRequest, AcceptanceClaim), OperationError>> { + Box::pin(async move { + let permit = self + .0 + .authorize_stock_exact_replay(select(value, recipient), proof) + .await?; + let (request, report) = permit.into_recovery_request(call)?; + Ok((request, claim(&report))) + }) + } + fn install<'a>( + &'a self, + value: AcceptanceSelection, + proof: &'a AttachmentProof, + ) -> HostFuture<'a, Result<AcceptanceInstallationOutcome, OperationError>> { + Box::pin(async move { + match self + .0 + .install_stock_agreement( + StockInstallationRequest::new( + value.binding, + value.minimum, + value.operation, + value.digest, + ), + proof, + ) + .await? + { + StockInstallationOutcome::Installed(value) => Ok( + AcceptanceInstallationOutcome::Installed(Box::new(installation(&value))), + ), + StockInstallationOutcome::Unknown(value) => { + Ok(AcceptanceInstallationOutcome::Unknown(value)) + } + } + }) + } +} diff --git a/crates/radroots/src/native_commerce_tests.rs b/crates/radroots/src/native_commerce_tests.rs @@ -0,0 +1,921 @@ +//! Real facade, SQLx and local crypto with explicitly controlled command IO. +//! This is no live Nostr transport or host-custody qualification. +use super::{Client, NativeConfig, StartMode}; +use radroots_domain::{CommandContextData, OperationId, PoolId, PublicKey, UnixSeconds}; +use radroots_execution::{ + session::{ + HostFuture, + command::{CommandIo, CommandRuntime, capture_dm_route, selected_dm_targets}, + }, + workspace::CommandContext, +}; +use radroots_nostr::{key::SecretKey, public_ingress::ObservedHead, signing::LocalSigner}; +use radroots_protocol::{ + command::{AcceptOrderInput, AllocationSelection, CapturedOrderAcceptance}, + nip59::CapturedDmRoute, +}; +use radroots_secrets::{ + SecretId, SecretRef, + envelope::Nonce, + file::{FileOpenMode, FileProvider}, + id::{BackendKind, KeyVersion}, + provider::AccessPolicy, + wrapping::SecretMaterial, +}; +use radroots_signing::{ + SignReceipt, SignRequest, Signer, SignerStatus, + issuance::{ + ExactRecoveryCapability, ExactRecoveryOutcome, ExactRecoveryRequest, SigningIntent, + SigningOutcome, + }, + provider::{ + ParticipantProvider, PrivateCiphertext, PrivateText, ProviderCall, ProviderError, + ProviderState, SignerCallbacks, SignerHandle, + }, + signer::BoxFuture, +}; +use radroots_storage::{ + command::{EnvelopeCandidate, OperationError, PublicationWork}, + event::SourceGeneration, + inventory::{InventoryCheckpointRef, InventoryOutcome, InventoryRequest, InventoryStore}, + workspace::{ + AttachmentProof, WorkspaceClock, WorkspaceError, + seller_stock::{ + SellerAuthoritySelection, StockGrantScope, StockListingCheckpointRef, StockResources, + StockSourceCheckpointRef, + }, + }, +}; +use radroots_storage_sqlite::{ + OpenMode, OpenOptions, Paths, + workspace::{ + NativeWorkspace, SellerStockConfig, StockConsentCapture, StockConsentMode, StockEnrollment, + StockGrantEnrollment, StockListingCapture, StockRequestSnapshot, StockSnapshotRequest, + StockSourceCapture, WorkspaceCrypto, + }, +}; +use radroots_transport::{Target, TargetSet}; +use std::{ + num::NonZeroU64, + sync::{ + Arc, Weak, + atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}, + }, +}; + +fn data() -> serde_json::Value { + serde_json::from_str(include_str!( + "../tests/fixtures/ordinary_acceptance/inputs.v1.json" + )) + .unwrap() +} +fn proof(value: &AttachmentProof) -> AttachmentProof { + value + .with_secret(|b| AttachmentProof::from_protected_input(b)) + .unwrap() +} +struct Clock(AtomicU64); +impl WorkspaceClock for Clock { + fn now(&self) -> Result<UnixSeconds, WorkspaceError> { + UnixSeconds::new(self.0.load(Ordering::SeqCst)).map_err(|_| WorkspaceError::Unavailable) + } +} +struct Control { + recovery_supported: AtomicBool, + signs: AtomicUsize, + recoveries: AtomicUsize, + fail_self: AtomicBool, + pause_peer: AtomicBool, + entered: tokio::sync::Notify, + release: tokio::sync::Notify, +} +impl Control { + fn new() -> Self { + Self { + recovery_supported: AtomicBool::new(true), + signs: AtomicUsize::new(0), + recoveries: AtomicUsize::new(0), + fail_self: AtomicBool::new(false), + pause_peer: AtomicBool::new(false), + entered: tokio::sync::Notify::new(), + release: tokio::sync::Notify::new(), + } + } +} +struct Provider { + inner: LocalSigner, + control: Arc<Control>, +} +impl Signer for Provider { + fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> { + self.inner.status() + } + fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> { + panic!("acceptance must never invoke legacy signing") + } +} +impl ParticipantProvider for Provider { + fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> { + Box::pin(async move { + let state = self.inner.provider_state().await?; + Ok(if self.control.recovery_supported.load(Ordering::SeqCst) { + state + } else { + state.with_exact_recovery(ExactRecoveryCapability::Unavailable) + }) + }) + } + fn encrypt_private( + &self, + c: ProviderCall, + p: PublicKey, + t: PrivateText, + ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> { + self.inner.encrypt_private(c, p, t) + } + fn decrypt_private( + &self, + c: ProviderCall, + p: PublicKey, + t: PrivateCiphertext, + ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> { + self.inner.decrypt_private(c, p, t) + } + fn sign_exact(&self, intent: SigningIntent) -> BoxFuture<'_, SigningOutcome> { + 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) { + return SigningOutcome::not_dispatched(intent.binding(), ProviderError::Cancelled); + } + let result = self.inner.sign_exact(intent).await; + if !is_self && self.control.pause_peer.swap(false, Ordering::SeqCst) { + self.control.entered.notify_one(); + self.control.release.notified().await; + } + result + }) + } + fn recover_exact(&self, request: ExactRecoveryRequest) -> BoxFuture<'_, ExactRecoveryOutcome> { + Box::pin(async move { + self.control.recoveries.fetch_add(1, Ordering::SeqCst); + self.inner.recover_exact(request).await + }) + } +} +struct Callbacks; +impl SignerCallbacks for Callbacks { + fn quiesce(&self) -> BoxFuture<'_, Result<(), ProviderError>> { + Box::pin(async { Ok(()) }) + } + fn close(&self) -> BoxFuture<'_, Result<(), ProviderError>> { + Box::pin(async { Ok(()) }) + } +} +struct Io(Arc<Clock>); +fn targets() -> TargetSet { + TargetSet::new(vec![Target::nostr_relay("wss://relay.example").unwrap()]).unwrap() +} +impl CommandIo for Io { + fn enabled(&self) -> bool { + true + } + fn now(&self) -> Result<UnixSeconds, OperationError> { + self.0.now().map_err(Into::into) + } + fn seal_time(&self, now: UnixSeconds) -> Result<UnixSeconds, OperationError> { + Ok(now) + } + fn route( + &self, + recipient: PublicKey, + _: NonZeroU64, + ) -> HostFuture<'_, Result<CapturedDmRoute, OperationError>> { + Box::pin(async move { + let value = data(); + let row = value["stock_routes"] + .as_array() + .unwrap() + .iter() + .find(|v| v["recipient"].as_str().unwrap() == recipient.to_hex()) + .unwrap(); + capture_dm_route(recipient, [row["raw"].as_str().unwrap()], &targets()) + }) + } + fn targets(&self, route: &CapturedDmRoute) -> Result<TargetSet, OperationError> { + selected_dm_targets(route, &targets()) + } + fn publication_policy(&self) -> radroots_transport::policy::SatisfactionPolicy { + panic!("acceptance does not start D") + } + fn envelope(&self, _: PublicationWork, _: &str) -> Result<EnvelopeCandidate, OperationError> { + panic!("acceptance does not wrap") + } + fn delivery_id(&self) -> Result<String, OperationError> { + panic!("acceptance does not claim D") + } + fn publish( + &self, + _: radroots_transport::sink::DeliveryRequest, + _: TargetSet, + ) -> HostFuture<'_, Result<radroots_transport::DeliveryReceipt, radroots_transport::SinkFailure>> + { + panic!("acceptance does not publish") + } +} +struct Rig { + vault: Arc<FileProvider>, + _temp: tempfile::TempDir, + client: Client, + native: NativeWorkspace, + enrollment: StockEnrollment, + scope: radroots_execution::workspace::WorkspaceSession, + clock: Arc<Clock>, + control: Arc<Control>, + provider: Weak<Provider>, +} +impl Rig { + async fn new() -> Self { + let temp = tempfile::tempdir().unwrap(); + let root = temp.path().canonicalize().unwrap(); + let vault = Arc::new( + FileProvider::open( + root.join("vault"), + FileOpenMode::CreateNew, + SecretMaterial::from_slice(&[0xa5; 32]).unwrap(), + ) + .unwrap(), + ); + let reference = SecretRef::new( + SecretId::parse("workspace-key").unwrap(), + BackendKind::File, + KeyVersion::new(1).unwrap(), + ); + vault + .provision( + &reference, + &SecretMaterial::from_slice(&[0x41; 32]).unwrap(), + Nonce::new([0x11; 24]), + ) + .unwrap(); + let crypto = WorkspaceCrypto::new( + vault.clone(), + reference, + SecretMaterial::from_slice(&[0x41; 32]).unwrap(), + AccessPolicy::standard(), + ) + .unwrap(); + let clock = Arc::new(Clock(AtomicU64::new(150))); + let control = Arc::new(Control::new()); + let provider = Arc::new(Provider { + inner: LocalSigner::with_clock( + SecretKey::parse(&format!("{:064x}", 3)).unwrap(), + || Ok(150000), + ) + .unwrap() + .with_nonce_source(Arc::new(radroots_nostr::signing::OsNonceSource)), + control: control.clone(), + }); + let key = provider.inner.public_key(); + assert_eq!(key.to_hex(), data()["scope"]["seller"].as_str().unwrap()); + let enrollment = StockEnrollment::prepare( + SellerStockConfig::new( + key, + key, + "synthetic-ordinary-acceptance", + UnixSeconds::new(300).unwrap(), + ) + .unwrap(), + clock.as_ref(), + ) + .unwrap(); + let native = NativeWorkspace::initialize_seller_stock( + &root.join("stock"), + &enrollment, + crypto, + clock.clone(), + ) + .await + .unwrap(); + std::fs::create_dir(root.join("cache")).unwrap(); + let options = OpenOptions::new( + Paths::from_directory(root.join("cache")).unwrap(), + OpenMode::Create, + ) + .with_source_generation(SourceGeneration::new([17; 32]).unwrap(), 1) + .unwrap(); + let mut client = + Client::open(NativeConfig::public_read(options).with_workspace(native.clone())) + .await + .unwrap(); + // Only IO is controlled. This preserves the actual client task host, + // attached scopes, stock evidence owner and concrete native adapter. + client.session = client + .session + .clone() + .with_command_runtime(Arc::new(CommandRuntime::new(Arc::new(Io(clock.clone()))))); + let scope = client + .attach(enrollment.input().clone(), proof(enrollment.proof())) + .await + .unwrap(); + let weak = Arc::downgrade(&provider); + client + .attach_signer(SignerHandle::new(provider, Arc::new(Callbacks))) + .await + .unwrap(); + client.start(StartMode::LocalOnly).await.unwrap(); + let rig = Self { + vault, + _temp: temp, + client, + native, + enrollment, + scope, + clock, + control, + provider: weak, + }; + rig.seed().await; + rig + } + async fn minima( + &self, + ) -> ( + StockSourceCheckpointRef, + StockListingCheckpointRef, + InventoryCheckpointRef, + ) { + let current = self + .native + .stock_authority(self.enrollment.input().clone(), self.enrollment.proof()) + .await + .unwrap(); + ( + current.source_checkpoint().unwrap(), + current.listing_checkpoint().unwrap(), + current.inventory_checkpoint().unwrap(), + ) + } + fn context(&self, id: u8) -> CommandContextData { + self.scope + .command_context( + OperationId::from_bytes([id; 32]), + None, + None, + UnixSeconds::new(230).unwrap(), + ) + .unwrap() + .data() + .clone() + } + async fn seed(&self) { + let value = data(); + let key = self.enrollment.input().participant(); + let raw = value["listing_raw"].as_str().unwrap(); + let listing: serde_json::Value = serde_json::from_str(raw).unwrap(); + let d = listing["tags"] + .as_array() + .unwrap() + .iter() + .find(|v| v[0] == "d") + .unwrap()[1] + .as_str() + .unwrap(); + let mut head = ObservedHead::listing(key, d).unwrap(); + head.observe(raw).unwrap(); + let capture = StockListingCapture::prepare( + SellerAuthoritySelection::from_attachment(self.enrollment.input()), + &head, + ) + .unwrap(); + let (_, minimum, _) = self.minima().await; + self.native + .retain_stock_listing( + self.scope.binding().clone(), + minimum, + &capture, + self.enrollment.proof(), + ) + .await + .unwrap(); + for row in value["sources"].as_array().unwrap() { + let local = LocalSigner::with_clock( + SecretKey::parse(&format!( + "{:064x}", + row["recipient_scalar"].as_u64().unwrap() + )) + .unwrap(), + || Ok(1000), + ) + .unwrap(); + let call = ProviderCall::new( + local.public_key(), + NonZeroU64::new(2000).unwrap(), + radroots_signing::request::CancellationSignal::new(), + ); + let opened = + radroots_nostr::commerce::open(&local, call, row["raw_wrap"].as_str().unwrap()) + .await + .unwrap(); + let capture = StockSourceCapture::prepare( + SellerAuthoritySelection::from_attachment(self.enrollment.input()), + &opened, + ) + .unwrap(); + let (minimum, _, _) = self.minima().await; + self.native + .retain_stock_source( + self.scope.binding().clone(), + minimum, + &capture, + self.enrollment.proof(), + ) + .await + .unwrap(); + } + let snapshot = self.request().await; + let line = &snapshot.terms().lines()[0]; + for (id, wire) in [ + ( + 80, + serde_json::json!({"type":"stock.create_pool","context":self.context(80),"input":{"id":PoolId::from_bytes([80;32]),"label":"private test stock","unit":"each","tick_scale":"0","initial_quantity":"10"}}), + ), + ( + 81, + serde_json::json!({"type":"stock.map_option","context":self.context(81),"input":{"listing":line.source().coordinate(),"option_id":line.option_id(),"pool_id":PoolId::from_bytes([80;32]),"expected_mapping_version":"0","per_sale_unit":{"amount":"1","unit":"each"}}}), + ), + ] { + assert_eq!( + wire["context"]["operation_id"], + serde_json::to_value(OperationId::from_bytes([id; 32])).unwrap() + ); + let (_, _, minimum) = self.minima().await; + let request = InventoryRequest::from_protected_wire( + self.scope.binding().clone(), + minimum, + &serde_json::to_vec(&wire).unwrap(), + ) + .unwrap(); + assert!(matches!( + self.native + .execute_inventory(request, proof(self.enrollment.proof())) + .await + .unwrap(), + InventoryOutcome::Committed(_) + )); + } + } + async fn request(&self) -> StockRequestSnapshot { + let (private, public, minimum) = self.minima().await; + self.native + .stock_order_request( + self.scope.binding().clone(), + minimum, + private, + public, + data()["request"].as_str().unwrap().parse().unwrap(), + self.enrollment.proof(), + ) + .await + .unwrap() + } + async fn captured(&self) -> (CapturedOrderAcceptance, CommandContext) { + let snapshot = self.request().await; + let mut value = serde_json::json!({"type":"orders.accept","context":self.context(90),"input":{"request":snapshot.request(),"terms_digest":snapshot.terms_digest(),"allocation":{"type":"automatic"}}}); + value["context"]["expected"] = serde_json::json!({"agreement":null,"buyer_head":snapshot.request(),"checkpoint":snapshot.checkpoint(),"order_id":snapshot.scope().order_id(),"seller_sequence":"0"}); + let first = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap(); + value["context"]["approval"] = serde_json::json!({"intent_digest":first.approval_intent_digest(),"scope":"orders.accept","expires_at":"230"}); + let command = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap(); + let context = self + .scope + .command_context( + command.context().operation_id(), + command.context().expected().cloned(), + command.context().approval().cloned(), + UnixSeconds::new(230).unwrap(), + ) + .unwrap(); + let capture = StockConsentCapture::prepare( + SellerAuthoritySelection::from_attachment(self.enrollment.input()), + self.enrollment.input().grant_id(), + StockConsentMode::ExecuteAndRecover, + StockResources::all_pools(), + UnixSeconds::new(230).unwrap(), + CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), + ) + .unwrap(); + let (_, _, minimum) = self.minima().await; + self.native + .issue_stock_consent( + self.scope.binding().clone(), + minimum, + &capture, + self.enrollment.proof(), + ) + .await + .unwrap(); + (command, context) + } + async fn accept(&self) -> (CapturedOrderAcceptance, crate::orders::AcceptanceStatus) { + let (command, context) = self.captured().await; + let (private, public, minimum) = self.minima().await; + let input = AcceptOrderInput::new( + command.input().request(), + command.input().terms_digest(), + AllocationSelection::automatic(), + ); + let status = self + .client + .orders(&self.scope) + .accept(context, minimum, private, public, input) + .await + .unwrap(); + (command, status) + } +} + +#[tokio::test] +async fn ordinary_acceptance_uses_real_t0_t1_s_t2_and_preserves_original_retry() { + let r = Rig::new().await; + let (command, status) = r.accept().await; + assert!(status.installation().is_some()); + assert!(status.recipients().iter().all(|v| v.evidence.is_some())); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + let (_, _, minimum) = r.minima().await; + let observed = r + .client + .orders(&r.scope) + .acceptance_status(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_eq!(observed.installation(), status.installation()); + r.clock.0.store(231, Ordering::SeqCst); + let refused = r + .client + .orders(&r.scope) + .resume_acceptance(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap_err(); + assert_eq!(refused.code(), crate::Code::DeadlineExceeded); + // Expired issuing consent is not silently renewed. An actual authorized + // RecoverOnly replacement permits historical reads, never a new signature. + let child = StockGrantEnrollment::prepare( + &SellerAuthoritySelection::from_attachment(r.enrollment.input()), + "replacement recovery operator".into(), + UnixSeconds::new(290).unwrap(), + StockGrantScope::full_inventory(), + ) + .unwrap(); + r.native + .enroll_stock_grant( + r.scope.binding().clone(), + minimum, + r.enrollment.proof(), + &child, + ) + .await + .unwrap(); + let (_, _, minimum) = r.minima().await; + let capture = StockConsentCapture::prepare( + SellerAuthoritySelection::from_attachment(r.enrollment.input()), + child.input().grant_id(), + StockConsentMode::RecoverOnly, + StockResources::all_pools(), + UnixSeconds::new(280).unwrap(), + CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), + ) + .unwrap(); + r.native + .issue_stock_consent( + r.scope.binding().clone(), + minimum, + &capture, + r.enrollment.proof(), + ) + .await + .unwrap(); + let recovery_scope = r + .client + .attach(child.input().clone(), proof(child.proof())) + .await + .unwrap(); + let resumed = r + .client + .orders(&recovery_scope) + .resume_acceptance(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_eq!(resumed.installation(), status.installation()); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); +} + +#[tokio::test] +async fn lost_observer_cannot_discard_actual_peer_artifact_and_close_installs_before_key_disposal() +{ + let r = Rig::new().await; + r.control.pause_peer.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 waiter = 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), 1); + waiter.abort(); + assert!(waiter.await.unwrap_err().is_cancelled()); + let mut closing = Box::pin(r.client.close()); + assert!(futures::poll!(closing.as_mut()).is_pending()); + assert!(r.provider.upgrade().is_some()); + r.control.release.notify_one(); + closing.await.unwrap(); + assert!(r.provider.upgrade().is_none()); + 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()); + assert_eq!( + snapshot + .recipients() + .iter() + .filter(|v| v.first_evidence().is_some()) + .count(), + 1 + ); + assert_eq!( + snapshot.preparation().attempt().operation_id(), + command.context().operation_id() + ); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); + reopened.close().await.unwrap(); +} + +#[tokio::test] +async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_recovery() { + let r = Rig::new().await; + r.control.fail_self.store(true, Ordering::SeqCst); + let (command, status) = r.accept().await; + let installation = status + .installation() + .expect("peer S must install before self refusal"); + assert_eq!( + status + .recipients() + .iter() + .filter(|v| v.evidence.is_some()) + .count(), + 1 + ); + assert!(!status.aborted()); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + r.control.fail_self.store(false, Ordering::SeqCst); + let (_, _, minimum) = r.minima().await; + let resumed = r + .client + .orders(&r.scope) + .resume_acceptance(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_eq!(resumed.installation(), Some(installation)); + 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); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); +} + +#[tokio::test] +async fn later_local_capability_cannot_upgrade_an_original_non_replayable_unknown_claim() { + let r = Rig::new().await; + r.control.recovery_supported.store(false, Ordering::SeqCst); + r.control.fail_self.store(true, Ordering::SeqCst); + let (command, status) = r.accept().await; + assert!(status.installation().is_some()); + r.control.fail_self.store(false, Ordering::SeqCst); + r.control.recovery_supported.store(true, Ordering::SeqCst); + let (_, _, minimum) = r.minima().await; + let resumed = r + .client + .orders(&r.scope) + .resume_acceptance(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert_eq!(resumed.installation(), status.installation()); + assert_eq!( + resumed + .recipients() + .iter() + .filter(|v| v.evidence.is_some()) + .count(), + 1 + ); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); + assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0); + assert!(!resumed.aborted()); + r.client.close().await.unwrap(); +} + +#[tokio::test] +async fn actual_s_insert_failure_retains_obtained_peer_bytes_and_resumes_without_peer_reissue() { + use sqlx::Connection; + let r = Rig::new().await; + r.control.pause_peer.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 waiter = 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(); + // The real peer artifact already exists. Fail the actual SQL INSERT, + // independently of Core's retained-material owner and transaction result. + let path = r._temp.path().join("stock/stock_execution_v1.sqlite"); + let mut fault = sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())) + .await + .unwrap(); + sqlx::query("CREATE TRIGGER controlled_s_failure BEFORE INSERT ON stock_signing_evidence BEGIN SELECT RAISE(ABORT, 'controlled_s_failure'); END").execute(&mut fault).await.unwrap(); + r.control.release.notify_one(); + let error = waiter.await.unwrap().unwrap_err(); + assert_eq!(error.code(), crate::Code::StorageFailure); + assert_eq!(error.context().admission(), crate::Admission::Confirmed); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); + 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, + AcceptOrderInput::new( + command.input().request(), + command.input().terms_digest(), + AllocationSelection::automatic(), + ), + ) + .await + .unwrap_err(); + assert_eq!(blocked.code(), crate::Code::RecoveryRequired); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 1); + sqlx::query("DROP TRIGGER controlled_s_failure") + .execute(&mut fault) + .await + .unwrap(); + fault.close().await.unwrap(); + r.client.stock(&r.scope).drain_evidence().await.unwrap(); + let status = r + .client + .orders(&r.scope) + .resume_acceptance(minimum, command.context().operation_id(), command.digest()) + .await + .unwrap(); + assert!(status.installation().is_some()); + assert!(status.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), 0); + let pool = r + .native + .pool( + r.scope.binding().clone(), + status.checkpoint(), + PoolId::from_bytes([80; 32]), + proof(r.enrollment.proof()), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(pool.snapshot().balances().physical().available.get(), 7); + assert_eq!( + pool.snapshot().balances().physical().preparatory_hold.get(), + 0 + ); + assert_eq!( + pool.snapshot().balances().physical().committed_hold.get(), + 3 + ); + r.client.close().await.unwrap(); + assert!(r.provider.upgrade().is_none()); +} + +#[tokio::test] +async fn identical_authenticated_foreign_scope_cannot_start_this_clients_acceptance() { + let r = Rig::new().await; + let (command, _) = r.captured().await; + let (private, public, minimum) = r.minima().await; + let path = r._temp.path().join("other_cache"); + std::fs::create_dir(&path).unwrap(); + let options = OpenOptions::new(Paths::from_directory(path).unwrap(), OpenMode::Create) + .with_source_generation(SourceGeneration::new([19; 32]).unwrap(), 1) + .unwrap(); + let other = Client::open(NativeConfig::public_read(options).with_workspace(r.native.clone())) + .await + .unwrap(); + let foreign = other + .attach(r.enrollment.input().clone(), proof(r.enrollment.proof())) + .await + .unwrap(); + assert_eq!(foreign.binding().input(), r.scope.binding().input()); + let context = foreign + .command_context( + command.context().operation_id(), + command.context().expected().cloned(), + command.context().approval().cloned(), + UnixSeconds::new(230).unwrap(), + ) + .unwrap(); + assert_eq!(context.data(), command.context()); + let error = r + .client + .orders(&foreign) + .accept( + context, + minimum, + private, + public, + AcceptOrderInput::new( + command.input().request(), + command.input().terms_digest(), + AllocationSelection::automatic(), + ), + ) + .await + .unwrap_err(); + assert_eq!(error.code(), crate::Code::Unauthorized); + assert_eq!(error.context().admission(), crate::Admission::NotAdmitted); + assert_eq!(r.minima().await.2, minimum); + assert_eq!(r.control.signs.load(Ordering::SeqCst), 0); + r.client.close().await.unwrap(); + other.close().await.unwrap(); +} diff --git a/crates/radroots/src/orders.rs b/crates/radroots/src/orders.rs @@ -0,0 +1,87 @@ +//! Ordinary captured order acceptance and original recovery through Core. +use crate::{Client, CommandContext, Result, WorkspaceSession}; +use radroots_domain::{CommandDigest, OperationId}; +pub use radroots_execution::session::commerce::{ + AcceptanceRecipient, AcceptanceStatus, InstalledAcceptance, +}; +pub use radroots_protocol::command::AcceptOrderInput; +use radroots_storage::{ + inventory::InventoryCheckpointRef, + workspace::seller_stock::{StockListingCheckpointRef, StockSourceCheckpointRef}, +}; + +/// Borrowed order workflows for one explicitly selected client-owned scope. +pub struct Orders<'a> { + client: &'a Client, + scope: WorkspaceSession, +} +impl<'a> Orders<'a> { + pub(crate) const fn new(client: &'a Client, scope: WorkspaceSession) -> Self { + Self { client, scope } + } + /// Owns captured acceptance through actual native T0/T1/S and initial T2. + /// Inspect independent recipient/installation facts; this performs no gift + /// wrapping or relay publication. Available command IO determines whether + /// preparation can proceed to signing; a pending report is not acceptance. + pub async fn accept( + &self, + context: CommandContext, + minimum: InventoryCheckpointRef, + sources: StockSourceCheckpointRef, + listings: StockListingCheckpointRef, + input: AcceptOrderInput, + ) -> Result<AcceptanceStatus> { + self.client + .session + .accept_stock_order( + self.client.inventory()?, + self.client.acceptance_store()?, + &self.scope, + context, + minimum, + sources, + listings, + input, + ) + .await + } + /// Explicitly resumes captured original work. Existing non-replayable + /// claims never sign again; qualified replay uses the original host permit. + pub async fn resume_acceptance( + &self, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + ) -> Result<AcceptanceStatus> { + self.client + .session + .resume_stock_acceptance( + self.client.inventory()?, + self.client.acceptance_store()?, + &self.scope, + minimum, + operation, + digest, + ) + .await + } + /// Reads coherent original acceptance, independent signing and installation + /// facts without issuing, replaying or publishing any artifact. + pub async fn acceptance_status( + &self, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + ) -> Result<AcceptanceStatus> { + self.client + .session + .stock_acceptance_status( + self.client.acceptance_store()?, + &self.scope, + minimum, + operation, + digest, + ) + .await + } +} diff --git a/crates/radroots/tests/fixtures/ordinary_acceptance/README.md b/crates/radroots/tests/fixtures/ordinary_acceptance/README.md @@ -0,0 +1,8 @@ +# Ordinary acceptance inputs + +Literal selected fields and signed bytes from retained independent native stock/commerce vectors. They qualify source opening and original route cryptography; controlled command IO supplies fixed time and selected targets without a network-execution claim. + +- Source `crates/storage_sqlite/tests/fixtures/stock_history.v1.json`, SHA-256 `3aeefb11a077105d7a844b53e771922e6e555e118a361f22ce9d4b1877a325db`. +- Source `crates/storage_sqlite/tests/fixtures/commerce_signing.v1.json`, SHA-256 `1d0a2e846ed9308fb35f2b3046d6fa52f0cf95fe25b05b51fa5f06b41eb4e122`. + +Selected input SHA-256 `666e06b725f36434bccbd45e0a2d7ea4eaa7412ad504286f055124db28bbc5c6`. diff --git a/crates/radroots/tests/fixtures/ordinary_acceptance/inputs.v1.json b/crates/radroots/tests/fixtures/ordinary_acceptance/inputs.v1.json @@ -0,0 +1,51 @@ +{ + "listing_raw": "{\"id\":\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":100,\"kind\":30402,\"tags\":[[\"d\",\"01010101010101010101010101010101\"],[\"title\",\"Carrot bunch\"],[\"summary\",\"One bunch; CAD 3.25 per bunch\"],[\"published_at\",\"99\"],[\"location\",\"Example region\"],[\"radroots:price_unit\",\"bunch\"],[\"radroots:listing\",\"{\\\"authority\\\":null,\\\"default_option\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"fulfillment\\\":{\\\"area\\\":\\\"Example region\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"modes\\\":[\\\"pickup\\\"]},\\\"media\\\":[],\\\"options\\\":[{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"One bunch\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":0,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"325\\\"},\\\"tiers\\\":[],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"type\\\":\\\"unknown\\\"},\\\"unit\\\":{\\\"contents\\\":{\\\"type\\\":\\\"unspecified\\\"},\\\"label\\\":\\\"bunch\\\",\\\"type\\\":\\\"package\\\"}}],\\\"product\\\":{\\\"description\\\":\\\"Independent public conformance fixture\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example region\\\",\\\"producer\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\"},\\\"profile\\\":\\\"radroots.listing\\\",\\\"state\\\":\\\"active\\\",\\\"version\\\":1}\"],[\"status\",\"active\"],[\"price\",\"3.25\",\"CAD\"]],\"content\":\"Synthetic carrots; availability: active\",\"sig\":\"7ead70c1825f09d2fac04c0501baa4e5d46e0117d8d04b15cb901d663ef425c192a992d595b21dbaf1e73626706314a42111858556c65e27482d2ae7696329b5\"}", + "scope": { + "thread": "7171717171717171717171717171717171717171717171717171717171717171", + "order": "7272727272727272727272727272727272727272727272727272727272727272", + "buyer": "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5", + "seller": "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9" + }, + "request": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4", + "sources": [ + { + "name": "chat", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"666879832a53446ded9eee874a20f0a8dbd8aecc3aa827abb2dc700226e498d6\",\"pubkey\":\"609ae8d31e3b290e74483776c1c8dfc2756b87d9635d654eb9e1ca95c228b169\",\"created_at\":1699993999,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"AvtsQj1w6+FNiNZJS1vuRJCStI2GdYaND+0CZwrDu0D2nUnonQgk+bYTCrhXlyIBNDZuE5mgJu16hadaUbzHFPhNP4ZaXfQ6DziWcU/SZPDva9CDVC/6jeJDU5BYkVabiYsXKhjawEyWtTCb1TPYzThEARFgJypPLa9L1lSFePDL0B6yI9enHZhV7EgrYd9haV21kV7ViDLicopliAyWtuOAD0xIuvTK+KUWY1lnCCsSPLzV2amlWFcSYwcBZPaBVEzW47RHxckGuvJGWTou/1j4U2vHAPDAmxDRDo0SK8JSlt+BrkUiJ4nm5fBAfYlX1RvbVC7B1FaxZOIBZOFQeY4utrI0N0SeYa9igrcQtTKc7sSiKoo191t5WxVx/s3ij/gYHIykPpm+iSL+m7vWhL8cpiTLqpB4gptTVBgQEvhO7FnxT/CkxpIn0fDsUdIOv2HzoZV51j5a/fiUZAw5UikNNrD5lDGr8mKN7K4K9NWqmp3PeJ22M94hr2pnHlZYChqEQVNl8+KwVrrGO3JY6xUZ9abu1a6s2roO16zekjP3Q1plHvDgh4mmVuPz/+SE2JWKi6wvKor9xZKXM7Zo/hwzucvEfOnwb8cdMHlb3V4Flz8qxdxKL6IMYl2AjYTVRrTEPdBHPwtvdHwzuNgLGPmRMdGkoQKIn+q/Ozwrn5omR6fFXm7+2x0DWliRPcJEYY+sw87NVIfWdH6IYjuSoUZghzvj/xTLoXzizZOQ1jZUbXmBCKQOSjxbFwTeAGL9Dg93ODm+y0yNC/wn+gbThBDklzEp8R7RwX9nXpQ6pD2tVohwMfF5/dfsTLzQMPNO39NxAA6tAeYXJTEqLzduu+IkH2oBbuICtPCLHThXkHfpPP9ZWs1S11aVKwa2C0x36cuhCH1+O2Epj2JP9R5R3ueFWlMfnsImWvEvUFIIWR6GkxAjtsklguX7yGd2ayrqS8cq7OMovZ/yoZQHekSMK52M14DbjPwlqND85i4dIdCG5dFKL/jt75rBb8oIZo4PdCXDjjT/+z15ZJJRXWTo0L5wwWs33I3M0z4CVuttvU1x1S2SlOVrmsoth3G3dAth2fIZBpu0obFIa/SIb8Mfjvor5ak9DngqZuxjHQKAODsrDNtPp6ElAbrvneuMKz36z6yB9oOqGPlQ9/WDWKwoO8jG1g3YAzLZfvCdErCC1Y4RR1tz76Mc9lG/X8+MB9o4cIY7VySEpEzDw4uPgF18RkzdtQ1/QlfivxSrn5YkBqqH1dyYBMYfM3nn7wG2m2MuJJ0L\",\"sig\":\"93c75b35253544bd906121717e55212eff23ed1ba974bfa2dcecba691e59f73955bd525b084ade827f7dd7d3bba0da2f6f483a847f82dc5a208a901c5f532c38\"}", + "raw_seal": "{\"id\":\"5d9acde162186e8fe12a7b6d231105022a3c5e738c559fb2a4c50b09bce31a1c\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699995000,\"kind\":13,\"tags\":[],\"content\":\"ArJSyqyhXXntS/d1GY4Sd7Fqcl13Qg4Vcj13RR5blj2RW82o6CDBmXkOQtWJA+PVsV75B52AiHGugbydJGd/W5ns20d7T8c39YJLSesPDum6yGTWBqf9tCCF1tjhC/pChGucLy1ufpNcbi39qEKwJjifK+WV+K5P0m4HwbrdJOCpa5NUfBpstcS+ojp5Bt1e+TJHRq8TiV8/K2jdpC3GMwD7BlAQW13Reb2462lQOmFJnSo7EaPA2OkJunmyxFggGJfg1y3G1UieZpJYwGyu5WQ+qQoqv/141rF49y72ELpnihFVkjp+YXz9+/hUFIxKLoPETDWoaFrRB3P+AOoSnC2hrPy604Nth+fx7CO/LAGLNjVTu2YZWnnAGuTBK8+4AaykiJXKdWWYj/uavfPoApTV5xtEthgnGzmw2M9dgr/fX6TCJzca9ErLo0ZLbVU/9sV9E19eH3HOr9H1KX411WnSU72VrMxbbRdNIv/596E25DkVSuFK7+ckWnRQNXTqS/Hy\",\"sig\":\"d9a35f12946f0c907e6039fe51322b893b49b623be1f079d6964c12472b779ccc723611e395ff81c393ce3eb638ca29a3fd3db23ef7b6bf784862ffbfb17f3a8\"}", + "raw_rumor": "{\"id\":\"93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":102,\"kind\":14,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"Independent private question\"}", + "rumor_id": "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0", + "record_id": null + }, + { + "name": "quote", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"967260e452f4fb2ff723585b630f09d4aeacf7a5c6dc9a95248e9a9d709143a6\",\"pubkey\":\"27510ef82e4b2134180855bf0469d1f0f89b9afd573f27814a1bea509db7ecb7\",\"created_at\":1699993998,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"a41ff4e0c9937ccf3dbdf71a654531db8ee8550e6cb81ec6aaee95728447a42d75a7f334d80ffa54ce4f31d2aa094c38c59f9a7d370c3249c91c98ed985b10f0\"}", + "raw_seal": "{\"id\":\"1feab298d9fe39e3edc2d8e72eca407f55e4a103c57e97f38bd0e4c9aaca0f69\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":1699994999,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"e64a9dd82e7b5af781de41ce997535ccebb4e798ac2fc1e5a320c8bfd057a959e9df18b29cd62adfee4b9fe39e223eac947aa60c0593230c92a0eb1e4838b367\"}", + "raw_rumor": "{\"id\":\"a8004b5c71fe824c85fa4c68f53ba930658b4a531807dbf813baf9ad66336b81\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":100,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"100\\\",\\\"order_id\\\":null,\\\"parents\\\":[\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\",\\\"93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"250\\\",\\\"in_reply_to\\\":\\\"93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n\ud83e\udd6c\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\\u0000\\\\u0001\\\\u0002\\\\u0003\\\\u0004\\\\u0005\\\\u0006\\\\u0007\\\\b\\\\t\\\\n\\\\u000b\\\\f\\\\r\\\\u000e\\\\u000f\\\\u0010\\\\u0011\\\\u0012\\\\u0013\\\\u0014\\\\u0015\\\\u0016\\\\u0017\\\\u0018\\\\u0019\\\\u001a\\\\u001b\\\\u001c\\\\u001d\\\\u001e\\\\u001f \\\\\\\"\\\\\\\\/ \u00c5 A\u030a \u2028 \u2029 \ud83e\udd6c\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}}],\\\"fulfillment_charge\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"25\\\"},\\\"lines\\\":[{\\\"amount\\\":\\\"3\\\",\\\"fulfillment_group\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"maximum_line_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"439\\\"},\\\"option\\\":{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"One bunch\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":0,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"325\\\"},\\\"tiers\\\":[],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"type\\\":\\\"unknown\\\"},\\\"unit\\\":{\\\"contents\\\":{\\\"type\\\":\\\"unspecified\\\"},\\\"label\\\":\\\"bunch\\\",\\\"type\\\":\\\"package\\\"}},\\\"option_id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"},\\\"selected_tier_from\\\":\\\"2\\\",\\\"type\\\":\\\"fixed\\\"},\\\"product\\\":{\\\"description\\\":\\\"Independent public conformance fixture\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example region\\\",\\\"producer\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\"},\\\"source\\\":{\\\"coordinate\\\":{\\\"author\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"d\\\":\\\"01010101010101010101010101010101\\\",\\\"kind\\\":30402},\\\"event_id\\\":\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\"},\\\"source_lot_label\\\":\\\"Private lot A\\\"}],\\\"maximum_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"464\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"supply\\\":{\\\"type\\\":\\\"stock_backed\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"quote\\\",\\\"version\\\":1}\"}", + "rumor_id": "a8004b5c71fe824c85fa4c68f53ba930658b4a531807dbf813baf9ad66336b81", + "record_id": "ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a" + }, + { + "name": "request", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"5c2c1f608a3c97677df435ddb862253a8bf4b3f311ef8e83ad86aa8e5d432e05\",\"pubkey\":\"f16e7c7f134e0488b8fcea4c926b18a6a6a839af526eb5aa5163b57e0a01b39c\",\"created_at\":1699993997,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"AlfPpP4fhNP9i33WMR3zXHFoN13ve/ZCaMTqYm6GZp/BmLog2xfMsrd4V1QIksKcyQ3qdktYWjP/ZHowRqhI8PBKWs7jBgp3mOeKHVGJz/ahaZZZ2qJ7iu/HAGYaRCKWc5yKc0Mno2QVy1QyTleZAIaRq2VqSUerZDXHJhDms2v2vJK65s75oDHVRUhS7ekSQRJ8xXpx14cthtEfmakddqrjy49S2OrHzHwYwcOSpWBZaXzAagOA+sKo/wKy0mfPQjHUB/6mAxxmcj7TdcqoYfpUMR2dN5ovKDVrwMCN4Rd04rE7xfAWBTwEw6oGTItaXOGpjkXstlkwiNir0uSuBskF7U3CtahpoWEayg94sz+SHymRQaW64c9zT5t+przLBy6T1x4k9n66tk46DiRyu1BNBSLb+fBHdM7b5t7FN0mfR6glpHDk0obr9M/eW4o4/jCuKFWbyrrphr8RzMDmtesO2jVh6VAqcfHD0Lw3kOttds+Ocglk5DO1KnfvP2lkihtbiQiHR3q1Jbaz8/zt5IM98RjDIJDCM3aU7CI8PK+JRAClaDFl1ClcuD3cGnIYoMSV/J1vjxM2TByT1mfVWc5p8I6OBHS58cGDXHvZs0cmv2uvMBTa4o36XVfZjOuJZQaL8Pt8XZ/1xdkVe9xdGPWLp5rOKwvNGPUaip4zwBS/PQ0EeuHvDeCgsnwrhhItJjvgMIjaJ0+u6vXignsxv50rV5vRwAv8JsHlGcS7pyq5h9f+7aJMOjU1xgsen93qwa4RakLbHOT4YOKYWWoqnROrAO7JGNfFASKRs3NBVTUKLA5GSE0w9lllIil/GHTMuMVUiQiAZdnauG1nc0FOhF8ECWBCMoYn5WFFQPNjlRDP4gLRl47KxksQ9Y9gjdBU+c7c5Jnro8Nu95K3O+mIPCz9QvQkyYICWbnqhFbC+n3kF30lXKVraOzXkygGqfDgnBOU+LnTmmPJnjBJA1ETymxUsa/wGqac2kP2V9R84CMcR3Q8/hwVqVsmV8Yc0bi565dH98eG703QkxZaAmsM9Mx92oxtpwqIivqI56afeVTwsbBHzKgEq20EenuZ8bXyCyDUiTB3VDfNZUO+t2PmDtYB24Vu4Dltlx0dWD5abNZeb3dim4YaYlTtxbC2JfnDicsYZcG9wT1AXjchlQ8gR1kVr//mRYNfE3UKnpyYrR/nkzIBPu8NE6/Nn3Xj5jEmi5kUAzaj6ExUR73OcbOlxEW/HLNbBiaCGCzB/UHr3nySPpsmDxQbFaCsVpVmKsxRUjx4bGUQvOgSEgWhFaqQNNtCJTa6ezHMy/YBxz2duGyUfLRmHR+dHwU528BZTPb2vliSilDMp0qtvqQ3sLEHVBdNJWhDfB2Wv3jU7dVuv3Kj7sZF2xSaTqbEAeb8uf8+zDcYIaG1lmfU5HuLnMdQNddLQ7+f3u094kEltkf+HI2eRpGxduXGP98SET9/MIyJsY4IwaFogdSFmrEdV1Hhg0ipKtOoFYwaYkrnvAOgknCoBZT30fSHPzTXt5ZpmaKBwPzDKENc+rYeQjaC1FQsr5dKnd1cmD8Q+BjGMU/C8PBvFRd5J+hLis7HpLQP2ZGjNAxQ+Ieh3RcrXYvSHTeLtFPVDwIdi5AoRrxjmlM/to0uT5yIuJrFjikCCN25aTB6TwRcmsXdWFGQsm7qB/eQ9udri9QPY5F6b9HYPbNFx2rvnwN3B9eYibmlPPGtr8Bqdw2Tp+zKFoiM3BnND9pVxN98cqYe//Xj/RWnmooEZdlqgs0F4dYkfoXIEWx/XYXHKhPmHPny6C7qDE7PLCjFnECr5Y2lN4W0s7TWFXDfuj/Y9lxwh/Y+FtWz5b0kaK5hZAAAP7BRZGcxZBwSDnOkSYBRES+7TA29A3ghTKFt12zBjdPmvgjzAKzC78gR8u9mUdSLzWlqJzhuETOjlLuy3zcJBtomLfduqX6OnbTr2G6ikUITPPAUe8v8Drah9I4c86QcW4Yxz//boXVbVaMkn8sQW/2A+z5EG8R/lnOf7AsAU1cI6TDZaNtxYjsOZzT1W/ewP4Gy1MjyGOnWQABFesaYELRSv6Fd9duFcPpykiMTOSxqqNF9s2PAR6z6xsbjWZQeX4RiC/QfaYYXFhwTr/xB6DhO/+q1GrPYUoyGF9jLhgJsuFom73VFlGG4iJuFlkP1pCNkxWo32W41NdGYhw4ai9JvTbgcKCl7S5DHiZrJE7pbXpgfcsbuLL5Jq5p+EogSRRyriF2YJmJFHSfMcte27F4NGbnPU073b5IJhArZTekKoWOey1m6Nvc2AdxYHqO/C+IHA/mTmg6LAgl54l9Qtkf18XliDrZ/15j9ReFJWeewoTvSbWn8DOGa/CKIHMGYLFR6OYNJbEhB1jzb15priNVRd4g1DzTcGePJHn1iVw/4np4GlZSWYqr/38DVl6zS/eD6gVstEfNlsxSvMWefoo7SOlruOzRh5wQ1VrmUIsBrBeAjPV/Ad+8lZzIaRk3Ty2TROcFuFpi8qxCoF6y6k1GQ7f87DWNP5gYYKZ+GVMNrQTKG7YIQN9QQyziYGJwi8aD8KVA2xJXThvK9LIhqpwWJOi5EF5FTerv2y/FZh2rRsVDc2arEWVpWbJyV2gL2RHUhKU+hxZ/HEhiowuuZY+JjWAIHTqTzWW6tS2/y4QNDkLiPaSxXbJmQuZ434mHL82zXA2L01NGc+knc5sqA4N/6cAMDAqYrnUlUkyzl0TImcYCsuk6zZ5ePGZiuGT08SlnHMkglLtqYitQcTgXTMBV1DhD+EdO+zmkAjgAHfWDXfgzu8v/6NTDWB4MP3gA+mT/TfLwu1R1Gc+8s8TxEEQu5Amez8Pe0UEiPfKL0oAc/Oi6SL+1JrPd+XtqYLWN1o1A/L58g2k7rgFhGeJGZSfaPWxhPGvCGT3PA6Sj6qYkyTAunUsFzikyAXSdTZnmtQO6ZMuOOc09HugSK9VD5q0UpQ6xv/ZumbbJ9pTn5eWzAnFts/OYqoZ5Zo6Noo62mrJk2YGQNPoSqCjDZvWEbzyhZSODE+CNlGUESa3B3NjWZkNjzVHJ8PzUv8ChoRKFh2FtI1Je9TaDxszH7uf24xL0t7t49Vc0NYDGP1Np1KkEzZ1mQCvtdPu3hgYxPRkt0leEqsPwoJ/Vj3f0nmEqZkE5WEnv/2fxgAqfOgmY1iWvC2UpY6YqCMpOLQio7kvqolx3CyP7+j/rBGRYOlZ6Q52Yny/B/u1Qc/2xcdHxj+r06Qa1Y4XKMAoC5agN6KpzOyvHGEa7bVsFCtiCT+Gh09cZfO8/Um5xPJ0oBuphJA+eIuLWUL2CbMGcAv6/ntc3HmnpnP8AzAhkWuiMN9Fxe/QafOC782X04HS/YJw/upBoD6bp8FasoD8EZH/V5ikCug60kzQFnMHaIrD+qZ95d9AWXDZn/qeJ7a2pD3MPa1rLKjPk+SzF8Nl2aAOD32KebN4L+jDL2Fc+GOIKSqFEn1mPv36cVzir2OYSe7OZSdgsf2IMggVqO56lzAKja6KtcmVXLmjlFg+5YsjVWuHY7cVEseKcwTVInSU0xQOz8uHjeVJ8YJLU6Lbi4wrziWBIR8AN/Um12fKKBFOIKTHmSVK77PwKs9LilVpWjQOov0DHYAsjOzqNoXUFFgUiwJUvmrygqu3YnDK1k7BuhCZUTeDqBZSeTo9wIFRmJxTKfYY45lLFqZfwAyJpKLygwrXtff3C6BJGIJDzbPfzW1ftP8A2U7jgc8BGYIHENTZsjQOB1VRCFlnGIrXMyY/V5J5bCb0Pa/W4IX0u7gLuSIH+2xJbYzMvduiFIeDZvCN0NQ8DmOfibGdXhNavuZgNrvl9PX3Qn+47jBktjeJ7CZgpKDiSpWGKkQ/Ci4pVIJ1ZRofC1rTn3ZwxkbBowU4FAUuUVH6eWmnzY9L/8TNjtMXlF6cF120rPRx0dvv2bHNy/SXZI2iNAFQqCspvbfCCbxYS1pygctsqosIZxLd14Tyg6Q+xDQA5n4HFlygQ7RX3B7poEby13FVWwWFJT7VFj2xcCCF0fGeSpmesrfTZeMHZmb8e+s+gU8jkbrLXjoNUZceqJ3lvI3XWnC92vHoqCZyRt+yibxtm8jKOsc442T2HVbdbaPfcKkueEvs8gfCTA8tjl7iX2rNBdNUls5sw05o9L6mXQsYv2YgYRFpceyL2CYkykGMwjlyBJLEAH57gEto3aacCeGR0tVIkOXOe5U0t2OBaX6uGQcFXD0xNu0bB7uWXtEdZiBHU2D3ZoSx09GSn8BIOo0PH+fXRHDryd6lwz2vXb0+Y2ZquIRPk32vpO3IbxRrXCG/Kl/fkwox8hWid3jQ9xm0jI977D2E/TAd4YDbE5P1JRKU7PutSUr/o+BZ4BQg8NVm5Mu+XHm/WGeNhlhSmJdX0vO/oducvuMqh9Xgmt9pEHoXs0s9uMSEiaz4jkmvTLESxTC9fJsYXAo67pz64TlQLBa0eTIHKnA8Lh9IYhNAIrpITkUcwoXJUQwjW83YgB2lpgTVjtKpQy+tKzcBXUfJLH2kFtCncCI39rGDBf1vHECX/bIV/LXEIzsh/TJI5si3yYmT38zlUdPSvsEoVBkRyqiSaQxZADmvh82wJBU8RiQ6EvKbAtT4hjdPWJCZwwS+CI3mozhEAE5JdAh+0EVWm256D0QxLErJaafJIeHyidxhwLYi/JqJ+SCi790giWwZN59VGia0EOEms5dTs+rPnYvE8t5ym7bzOKTe6E1RXhK/PJhgEeEw7yoMXXpZ4ZB6lRwrzyC7KYL/1P57LnG+XhN0LewCynMKG4nz4R19bY6L42lt7f1VrDUmS7zjB4+Lqp+T76Xv0xLKGT30vEaWE2+NmhgoZVPZ0t2v7EeodWbMh+7zbIV+aM0n3yB/qk2SigAXo4jKGFBQNDNwb4/8grGtsCgk70D7nO33TVwRtnOCf8+wy3bSRxPeklItPbJQEywph68N5nJHHsud/uqbAQcMpCpJdQKr65xjsz3fZaCjiOrU1sO8GPEK8ZsGP6z+XLWU7FW7fn46oj7gJ8XT6tzKYY6cZh9AU3YG2X+UODanGJu5JPCI1Kuz6EnCCC/0glcusMa4EBgRP6W6GT2lHiH8wcAbsez5DQjiE75A/oZPx/DY2Ztq3kv9zuWZ1gANRYrJA8Km4hkkx7XdagHEqK4SdIs/jtcvU+0A0FV+31ORPl73fi76SDxNIWC47NaNtN2po1IN16Sy5Blw5sjQjf5prTckKTcfKl5ighnp5P+VTk2GVzEzcc3wmVLwhNHfxTQ4pFC3KLcylg0n1C7VqTwK4Dq1at5rQ1sCdmjqLRqMAdyoqYP++revflUpHLeyVS0ASvwJ4wFu1hADOOwgKPI35v0tBBTqvVRlLiH1DEn95gywzuPD4BteQPaeRHK/2u/qleXBZCzD2mpabPa2UB3Nsq2VOoi1A2hVHmBiDk7VkMNIQKo715W1fcW+PxKbc+WHe5vV1L4efc7k3g+ZHVxNkNw5qJHwTkP7UblUaVOUqMwuf+QKZ/ZfUX0I59O9h6ZZlsP8aZ6Qa7gKpxsLBGQmn5NZ93feOR6ZIUi1XVRq+9Xvn19Mb84yxnKHpwik7t3CLr2N2qXxyVXxx6JdFJvOwdnShUrUrpWY1AjGIXC+6IM77f6r5jFg1b29L+AdX7xTHV6w8gf6UeGOhwZSCtdX5opXNXohoIH8K1Bcmu8SHsXmvhkHC1sT4AQQdLzDOFy/PkxdVS4YZ6olPZI7e1hlSqJoFoTeTj7V5/wP2c+v8LCCkvW0bHxqMoGsPuBbKIy9ALuilw1sTEYWMi92MaB0PbB+LV8PM8GZOOyYH82GVCK5Xhx9qIVwZ6K6J6/r7NPav4US/lkgYRbeSAqHOTmMJuBvPNlb4D4CTG9k2fMGvkz/AicKu14Yu7bvaPImP64/mrnz7O4SHDGKLMTRun9VNVl3iuJehlHNlpiJBFlHGp9OeODv6gVtJLUpCttJUEqFY96BG+KxZzWPzUaM+ls7DGlkuChBYXWz63wRAlbVRmh/YfB9tb9GaeFUJlbdi+Ufp2CKUTIcpDvOVloujNezZXONxFPPT8W5lnHfqRvXwtbKC0ujI3I68XAqlXaMT+KBVa3+DS0/tt8lSl0ShfxMb7Wt1o9mNX/slcjXjmwGo+4/gEizPPoUbHnVGvuBKsBkUQRzSOPwoPwCrUc9Xq6OOhKcWKv8QpdFL+PFbAQQg/2u8aDs+w0Usmzjgpbc1TXxtFtw+FhkZaUa4dI4ctlKJhP6Q3JIVszMq5TYZJ/d76Fktg0b9FbXH4+8ivyxyFzv5XVxoozFUy3MIFfw2NKMhWYhVnHt8ZeUhd6dTCLfDDFWUKEuuAHiHak+YuO7/IQv3V3foz4B20pOvXUuJrT0Ax8fwk6eSgi2QeVDGEktjGne37CFNHIz4DmHWAGq7hAzC99u5psUIT+IoWHPkzSBjggMSs+a2nhebOyZPyyNbE9I4yaVj/f0nW4G1CABXQPpcCdcd7Do6U7mXjUwYZzVS4YsJAMRdYM1bs+YzuVOr6dJ0N5+ROmCx1WlrWEHQrmkiSMlr/jEKbLkQXHUhaOIsr9G13q9y0PD/P29HS2RyAuxpGV5Y4wSYvbuw7YvwII4iyWNMDW56h/Y1WQKkMS+YDFcANL5HAAExdsva3ZeRhMinSEVaGwRGNOtZKs69R8L5azvsqfshddgrOHiqCNEpy+yXXbGVYs5Krs7Ca3jkv0rm8FTKYmq3ok+AmXuGGLos7basCH13Sw3dPk5mtn73m2MmG1IjZmw2YCzByhd5WFhQ5qyZe3PpW1SuKaehxkgHs4q5sN843CceOAl+fI8qfK6ntbjSWNK7jN493Z55zU+pFa/uRub8gGF60P4ZU431mstvphMrt+lhQ058DbgJ04Xa+rTLnHM6t67Gp2+Rk7G1q/V6oK3IineucdPbI4CvCPbghyO+NT/ESgbaSzEPHWbfCal8BOpGaz6sUTYbAMBjsdfV05e3UO7OaM1f+IfERWif9OS/bNJ8Ld1jJFog+MJVtn4pVhRAwhXweP3tffVeklDTt1w+RJNSHQoCz0rZ6d2J21u3mraARLyzWPiC7e/ornEQJY19DtdyQ0S+HsuqD3t+5ac6gRPRTxeiFVwuhR8SCjncVKS0nv77IO/xUnxLnDCaNWAnZgL5W2xnPE1LX5adG6KL2GGEow3ouitwWiQnPSVyOAjahRc5bfUDZFsgREuuvY1KHr7pEgkhmAVIJCtphBBo077GZOkVKms9BzBRecwDRBTLsLQF9BZyGI1zbkcgncwejHZkoNBU/+SW8H0lIcjpAOQR69wvn2DRSjYc05HvYqgJuRRDwEy4hv2VQ2hOAl+q9akHSVlGB9DC/TqyjJbGMGI+i6JL9V2OtDZNZqlqf4yZYByLglodlUBg+TrbJpNyOPSQKIfpAq0nhhTX7jPzhHyQBLlOZbNlYrGNMFDYUuvb+Fph9ksQw1QfwSyiWYz6HOsA0c8cBys/t+HmPuewEden+s03IS/yzIdnNsUkGB2tiSrU0eUWPycxa0ynpzZx0yZoZ8wx2I7ChaD7RCq73Gkl8ZGVQVDDYxi78x1DEC7zK94iGFS9Caf2NM8GwsSiyhMuFbdLCoGeVYbpCvIQwJmtzBp0lVL3MlOQIofMQuu3TBwbMotPyDwcVGAM6fneZgcgruUmqAmOs5G1V4gqUzrDqUz1CtaK3YwqY8hrsz5eht42MzVsJh89Wbtq4M7Ovq+bh2R5dpoOGSb3hdHUMQeJWm8/OFvEpPPHKdGoVAZfhGQFZSfUbzC+liRO/Vv1riYZhcTkEjRIGmnRaZX/OPwjR6bB6dNuhjLtX6v+MbsOwzxlav1d4TiFiE34YG1pf/osxFGQkc6oZM4MQi82ByvJVEKPln474q+VN+OSjqZq0ndmRbcNeF+DLpJpep+FFJHuE6008QgR9C7DmOtPAFFEx1Lt2qDlzJYCZ9aK8olpy3bm+g881kLkh8EDsHrmoqgCaZ5PAkPY35SzTffly15ir0J5Rk5XbgSU9PozfG3mfS09WrWMMxamxHJF0l7SA+j69M0fWBE9ZJ6KYz/MrzDFHB+5hw7oO9igpH63kzWYcWXQw+uKQmE1IaeQXJgArK8w76ceiiRqnWwLM3gdJ2GH0m42c5PhMR6tibIdMHM2GIjCKzrAaHgQY5xTQWnLN4bQKFKTYK7Agqd3BfBiqn/+egulPcFb/pwy6kZif8XY4J5YrYrnnnkKRDX1DF2SFxx6Lu85vJ/dhGuZCHQ==\",\"sig\":\"92571039fe39f6ea248b33847439d7dc236f8038a7a1d9ceeb43402ccb097406c61787cfd92cf5645b27e6c1afb8d1ec8f52af6535a09e56f2408e21f41520a2\"}", + "raw_seal": "{\"id\":\"2c44aaeac89bdd311219641808d7a0b52ae82355a560a9ecdb0b34c06589dca4\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994998,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"d44a9f62325d71d7028535361553496aa80dbb4651362dd63636fcb881bda2c69e0b8ee7306aba8bde51bd3269a4af7e0810e20e0699f7216a55963a9077eef5\"}", + "raw_rumor": "{\"id\":\"18c1e8d91f002c999ef14227dc757aaf6c3fa088d7bd3d956dd15d16168d0227\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"101\\\",\\\"order_id\\\":\\\"7272727272727272727272727272727272727272727272727272727272727272\\\",\\\"parents\\\":[\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\",\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n\ud83e\udd6c\\\",\\\"contact\\\":null,\\\"instructions\\\":\\\"\\\\u0000\\\\u0001\\\\u0002\\\\u0003\\\\u0004\\\\u0005\\\\u0006\\\\u0007\\\\b\\\\t\\\\n\\\\u000b\\\\f\\\\r\\\\u000e\\\\u000f\\\\u0010\\\\u0011\\\\u0012\\\\u0013\\\\u0014\\\\u0015\\\\u0016\\\\u0017\\\\u0018\\\\u0019\\\\u001a\\\\u001b\\\\u001c\\\\u001d\\\\u001e\\\\u001f \\\\\\\"\\\\\\\\/ \u00c5 A\u030a \u2028 \u2029 \ud83e\udd6c\\\",\\\"mode\\\":\\\"pickup\\\",\\\"window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"}}}],\\\"fulfillment_charge\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"25\\\"},\\\"lines\\\":[{\\\"amount\\\":\\\"3\\\",\\\"fulfillment_group\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"id\\\":\\\"0505050505050505050505050505050505050505050505050505050505050505\\\",\\\"maximum_line_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"439\\\"},\\\"option\\\":{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"One bunch\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":0,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"325\\\"},\\\"tiers\\\":[],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"type\\\":\\\"unknown\\\"},\\\"unit\\\":{\\\"contents\\\":{\\\"type\\\":\\\"unspecified\\\"},\\\"label\\\":\\\"bunch\\\",\\\"type\\\":\\\"package\\\"}},\\\"option_id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":250,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"},\\\"selected_tier_from\\\":\\\"2\\\",\\\"type\\\":\\\"fixed\\\"},\\\"product\\\":{\\\"description\\\":\\\"Independent public conformance fixture\\\",\\\"name\\\":\\\"Carrots \ud83e\udd55\\\",\\\"origin_summary\\\":\\\"Example region\\\",\\\"producer\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\"},\\\"source\\\":{\\\"coordinate\\\":{\\\"author\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"d\\\":\\\"01010101010101010101010101010101\\\",\\\"kind\\\":30402},\\\"event_id\\\":\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\"},\\\"source_lot_label\\\":\\\"Private lot A\\\"}],\\\"maximum_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"464\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"supply\\\":{\\\"type\\\":\\\"stock_backed\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "18c1e8d91f002c999ef14227dc757aaf6c3fa088d7bd3d956dd15d16168d0227", + "record_id": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4" + } + ], + "stock_routes": [ + { + "recipient": "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5", + "event_id": "16882dbaca0f93c318de709de113844676061c46b96e228d57bb33a04abaec3c", + "raw": "{\"id\":\"16882dbaca0f93c318de709de113844676061c46b96e228d57bb33a04abaec3c\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":100,\"kind\":10050,\"tags\":[[\"relay\",\"wss://relay.example\"]],\"content\":\"\",\"sig\":\"dd3c46dcb74082347f6eafd9baa100dc9ac0ee6b082b9d0c5bc8ff0c920a34c5bb837e495fcab1ef62d2ca8b27607ca07a224997165f110975209a51b2e467ec\"}" + }, + { + "recipient": "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9", + "event_id": "9bb5389c6ea855662864a8e3910d0c483ba0e0a1ab2baf9e7193a7ed458d1c54", + "raw": "{\"id\":\"9bb5389c6ea855662864a8e3910d0c483ba0e0a1ab2baf9e7193a7ed458d1c54\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":100,\"kind\":10050,\"tags\":[[\"relay\",\"wss://relay.example\"]],\"content\":\"\",\"sig\":\"c32551e9168b5e0ed17b60d4ef6b8ad4302c7b3415850fe870007a95940ec116473feab11294335e726972c0a8b0788cf2cd699cc028e57653749fd74e1c68c9\"}" + } + ] +} diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -324,6 +324,14 @@ struct SigningIssuance { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct SigningPlanBinding { + ordinary_acceptance_owner: String, + ordinary_acceptance_facade: String, + ordinary_peer_installed_before_self_work: bool, + ordinary_accepted_task_survives_observer_loss: bool, + ordinary_obtained_owned_before_descriptor_conversion: bool, + ordinary_existing_claim_grants_first_dispatch: bool, + ordinary_replay_requires_original_policy_and_current_permit: bool, + ordinary_acceptance_implies_delivery: bool, crypto_verifier_owner: String, scoped_crypto_verification: String, predecessor_nostr_verifier_alias: bool, @@ -601,6 +609,27 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { .final_source_counts_and_witnesses_required && !stock.acceptance_preparation.signer_invoked && !stock.acceptance_preparation.agreement_installed + && stock.signing_plan_binding.ordinary_acceptance_owner + == "radroots_execution.CommandRuntime" + && stock.signing_plan_binding.ordinary_acceptance_facade == "radroots.Orders.accept" + && stock + .signing_plan_binding + .ordinary_peer_installed_before_self_work + && stock + .signing_plan_binding + .ordinary_accepted_task_survives_observer_loss + && stock + .signing_plan_binding + .ordinary_obtained_owned_before_descriptor_conversion + && !stock + .signing_plan_binding + .ordinary_existing_claim_grants_first_dispatch + && stock + .signing_plan_binding + .ordinary_replay_requires_original_policy_and_current_permit + && !stock + .signing_plan_binding + .ordinary_acceptance_implies_delivery && stock.signing_plan_binding.crypto_verifier_owner == "radroots_signing.commerce" && stock.signing_plan_binding.scoped_crypto_verification == "SignerSession.verify_commerce_plan" @@ -1693,6 +1722,23 @@ mod tests { #[test] fn signing_plans_require_complete_original_qualified_intents_before_any_signing() { for (field, bad) in [ + ( + "ordinary_obtained_owned_before_descriptor_conversion", + json!(false), + ), + ("ordinary_acceptance_owner", json!("application")), + ("ordinary_acceptance_facade", json!("radroots_sdk")), + ("ordinary_peer_installed_before_self_work", json!(false)), + ( + "ordinary_accepted_task_survives_observer_loss", + json!(false), + ), + ("ordinary_existing_claim_grants_first_dispatch", json!(true)), + ( + "ordinary_replay_requires_original_policy_and_current_permit", + json!(false), + ), + ("ordinary_acceptance_implies_delivery", json!(true)), ("crypto_verifier_owner", json!("radroots_nostr.commerce")), ( "scoped_crypto_verification",