lib

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

commit c0afe89a29bdb35d1db9971fab3e569ada57a0ab
parent 8f556774fe13d6629deec185c4a43241b9708aef
Author: triesap <tyson@radroots.org>
Date:   Sun, 25 Oct 2026 10:42:23 +0000

storage: prepare atomic stock acceptance

- Authenticate exact request sources and current issued command consent.
- Resolve complete allocations and commit all holds with one order fence.
- Recover original operations before fresh source or stock planning.
- Verify native and Linux faults, portable claims and retained catalogs.

Diffstat:
Mcontracts/api_baselines/radroots_domain.txt | 66++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcontracts/api_baselines/radroots_protocol.txt | 8++++++++
Mcontracts/api_baselines/radroots_storage_sqlite.txt | 39+++++++++++++++++++++++++++++++++++++++
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 24+++++++++++++++++++++---
Mcrates/domain/src/commerce/causal.rs | 10++++++++++
Acrates/domain/src/commerce/causal/request.rs | 187+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/domain/src/listing.rs | 4++++
Mcrates/domain/src/stock.rs | 4++++
Acrates/domain/src/stock/allocation.rs | 333+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/domain/tests/stock_allocation.rs | 123+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/protocol/src/commerce.rs | 2++
Acrates/protocol/src/commerce/coverage.rs | 102+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/protocol/tests/commerce_coverage.rs | 267+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/protocol/tests/fixtures/commerce_coverage.v1.json | 224+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/crypto.rs | 24++++++++++++++++++------
Mcrates/storage_sqlite/src/workspace/mod.rs | 9+++++----
Mcrates/storage_sqlite/src/workspace/stock.rs | 19+++++++++++--------
Mcrates/storage_sqlite/src/workspace/stock/consent.rs | 11+++++++----
Mcrates/storage_sqlite/src/workspace/stock/consent/test_provider.rs | 2+-
Mcrates/storage_sqlite/src/workspace/stock/grants.rs | 2+-
Mcrates/storage_sqlite/src/workspace/stock/inventory.rs | 5+++--
Acrates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs | 807+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/inventory/acceptance/codec.rs | 283+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/inventory/acceptance/plan.rs | 41+++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs | 57++++++++++++++++++++++++++++++++++++++++++++++++++++++---
Mcrates/storage_sqlite/src/workspace/stock/inventory/codec.rs | 4++--
Mcrates/storage_sqlite/src/workspace/stock/inventory/mapping.rs | 2+-
Mcrates/storage_sqlite/src/workspace/stock/inventory/plan.rs | 2+-
Mcrates/storage_sqlite/src/workspace/stock/ledger.rs | 6++++++
Mcrates/storage_sqlite/src/workspace/stock/public_source.rs | 1+
Acrates/storage_sqlite/src/workspace/stock/public_source/acceptance_tests.rs | 791+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/public_source/admission.rs | 146+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/public_source/history_tests.rs | 15+++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/public_source/request_tests.rs | 258+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/public_source/test_provider.rs | 4++--
Mcrates/storage_sqlite/src/workspace/stock/public_source/transaction.rs | 4++--
Mcrates/storage_sqlite/src/workspace/stock/schema.rs | 8++++----
Mcrates/storage_sqlite/src/workspace/stock/source.rs | 23+++++++++++++++++++++--
Mcrates/storage_sqlite/src/workspace/stock/source/checkpoint.rs | 6+++---
Mcrates/storage_sqlite/src/workspace/stock/source/history.rs | 35+++++++++++++++++++++++++++--------
Acrates/storage_sqlite/src/workspace/stock/source/request.rs | 215+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/source/transaction.rs | 71++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
Mcrates/storage_sqlite/src/workspace/stock/tests.rs | 33+++++++++++++++++++++------------
Mcrates/storage_sqlite/src/workspace/worker.rs | 102++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mcrates/storage_sqlite/tests/fixtures/stock_history.v1.json | 65++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mcrates/storage_sqlite/tests/support/stock_authority.rs | 2+-
Atools/protocol_oracle/commerce_coverage.mjs | 42++++++++++++++++++++++++++++++++++++++++++
Mtools/protocol_oracle/stock_history.mjs | 15+++++++++++++++
Mtools/xtask/src/architecture/decision_package.rs | 80++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
49 files changed, 4505 insertions(+), 78 deletions(-)

diff --git a/contracts/api_baselines/radroots_domain.txt b/contracts/api_baselines/radroots_domain.txt @@ -13,6 +13,22 @@ pub radroots_domain::causal::CausalReadiness::Complete pub radroots_domain::causal::CausalReadiness::Conflicted pub radroots_domain::causal::CausalReadiness::MissingHistory pub radroots_domain::causal::CausalReadiness::Uninterpreted +#[non_exhaustive] pub enum radroots_domain::causal::RequestClaimError +pub radroots_domain::causal::RequestClaimError::ClockAhead +pub radroots_domain::causal::RequestClaimError::Conflicted +pub radroots_domain::causal::RequestClaimError::ConflictingAuthorizations +pub radroots_domain::causal::RequestClaimError::Declined +pub radroots_domain::causal::RequestClaimError::Expired +pub radroots_domain::causal::RequestClaimError::InvalidGraph +pub radroots_domain::causal::RequestClaimError::MissingHistory +pub radroots_domain::causal::RequestClaimError::QuoteMismatch +pub radroots_domain::causal::RequestClaimError::RequiresReconciliation +pub radroots_domain::causal::RequestClaimError::Uninterpreted +pub radroots_domain::causal::RequestClaimError::Withdrawn +pub radroots_domain::causal::RequestClaimError::WrongRequest +impl core::error::Error for radroots_domain::causal::RequestClaimError +impl core::fmt::Display for radroots_domain::causal::RequestClaimError +pub fn radroots_domain::causal::RequestClaimError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_domain::causal::CausalAnalysis impl radroots_domain::causal::CausalAnalysis pub const fn radroots_domain::causal::CausalAnalysis::buyer_head(&self) -> core::option::Option<radroots_domain::RecordId> @@ -27,7 +43,9 @@ impl core::fmt::Debug for radroots_domain::causal::CausalAnalysis pub fn radroots_domain::causal::CausalAnalysis::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_domain::causal::CausalRecord<'a> impl<'a> radroots_domain::causal::CausalRecord<'a> +pub const fn radroots_domain::causal::CausalRecord<'a>::content(self) -> &'a radroots_domain::CommerceContent pub const fn radroots_domain::causal::CausalRecord<'a>::new(radroots_domain::RecordId, &'a radroots_domain::CommerceContent) -> Self +pub const fn radroots_domain::causal::CausalRecord<'a>::record_id(self) -> radroots_domain::RecordId impl core::fmt::Debug for radroots_domain::causal::CausalRecord<'_> pub fn radroots_domain::causal::CausalRecord<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_domain::causal::CausalScope @@ -38,9 +56,18 @@ pub fn radroots_domain::causal::CausalScope::new(radroots_domain::ThreadId, radr pub const fn radroots_domain::causal::CausalScope::order_id(self) -> radroots_domain::OrderId pub const fn radroots_domain::causal::CausalScope::seller(self) -> radroots_identity::key::PublicKey pub const fn radroots_domain::causal::CausalScope::thread_id(self) -> radroots_domain::ThreadId +pub struct radroots_domain::causal::InitialRequestClaim<'a> +impl radroots_domain::causal::InitialRequestClaim<'_> +pub const fn radroots_domain::causal::InitialRequestClaim<'_>::expires_at(&self) -> radroots_domain::UnixSeconds +pub const fn radroots_domain::causal::InitialRequestClaim<'_>::quote(&self) -> core::option::Option<radroots_domain::RecordId> +pub const fn radroots_domain::causal::InitialRequestClaim<'_>::request(&self) -> radroots_domain::RecordId +pub const fn radroots_domain::causal::InitialRequestClaim<'_>::terms(&self) -> &radroots_domain::Terms +impl core::fmt::Debug for radroots_domain::causal::InitialRequestClaim<'_> +pub fn radroots_domain::causal::InitialRequestClaim<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub const radroots_domain::causal::MAX_CAUSAL_RECORDS: usize pub const radroots_domain::causal::MAX_CAUSAL_SOURCES: usize pub fn radroots_domain::causal::analyze(radroots_domain::causal::CausalScope, &[radroots_domain::causal::CausalRecord<'_>], &[radroots_domain::SourceId], &[radroots_domain::SourceId]) -> core::result::Result<radroots_domain::causal::CausalAnalysis, radroots_domain::causal::CausalError> +pub fn radroots_domain::causal::prepare_initial_request<'a>(radroots_domain::causal::CausalScope, radroots_domain::RecordId, &[radroots_domain::causal::CausalRecord<'a>], &[radroots_domain::SourceId], &[radroots_domain::SourceId], radroots_domain::UnixSeconds) -> core::result::Result<radroots_domain::causal::InitialRequestClaim<'a>, radroots_domain::causal::RequestClaimError> pub mod radroots_domain::listing pub enum radroots_domain::listing::FulfillmentMode pub radroots_domain::listing::FulfillmentMode::Delivery @@ -160,6 +187,7 @@ pub const fn radroots_domain::listing::ListingTerms::fulfillment(&self) -> &radr pub fn radroots_domain::listing::ListingTerms::media(&self) -> &[radroots_domain::listing::Media] pub fn radroots_domain::listing::ListingTerms::new(radroots_domain::listing::ListingState, radroots_domain::listing::Product, radroots_domain::ListingOptionId, alloc::vec::Vec<radroots_domain::listing::ListingOption>, radroots_domain::listing::PublicFulfillment, core::option::Option<radroots_domain::AuthorityRef>, alloc::vec::Vec<radroots_domain::listing::Media>) -> core::result::Result<Self, radroots_domain::listing::ListingError> pub fn radroots_domain::listing::ListingTerms::options(&self) -> &[radroots_domain::listing::ListingOption] +pub const fn radroots_domain::listing::ListingTerms::product(&self) -> &radroots_domain::listing::Product pub const fn radroots_domain::listing::ListingTerms::state(&self) -> radroots_domain::listing::ListingState impl core::fmt::Debug for radroots_domain::listing::ListingTerms pub fn radroots_domain::listing::ListingTerms::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -204,6 +232,14 @@ pub fn radroots_domain::listing::SaleUnit::package_unspecified(&str) -> core::re impl core::fmt::Debug for radroots_domain::listing::SaleUnit pub fn radroots_domain::listing::SaleUnit::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub mod radroots_domain::stock +#[non_exhaustive] pub enum radroots_domain::stock::AllocationPlanError +pub radroots_domain::stock::AllocationPlanError::Capacity +pub radroots_domain::stock::AllocationPlanError::InvalidInput +pub radroots_domain::stock::AllocationPlanError::StaleState +pub radroots_domain::stock::AllocationPlanError::Unsupported +impl core::error::Error for radroots_domain::stock::AllocationPlanError +impl core::fmt::Display for radroots_domain::stock::AllocationPlanError +pub fn radroots_domain::stock::AllocationPlanError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub enum radroots_domain::stock::AvailableStockCorrection pub radroots_domain::stock::AvailableStockCorrection::Add pub radroots_domain::stock::AvailableStockCorrection::Remove @@ -235,6 +271,15 @@ pub fn radroots_domain::stock::MappingError::from(radroots_domain::stock::StockE impl core::error::Error for radroots_domain::stock::StockError impl core::fmt::Display for radroots_domain::stock::StockError pub fn radroots_domain::stock::StockError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_domain::stock::AllocationClaim +impl radroots_domain::stock::AllocationClaim +pub const fn radroots_domain::stock::AllocationClaim::expected_pool_version(self) -> radroots_domain::Sequence +pub const fn radroots_domain::stock::AllocationClaim::line_id(self) -> radroots_domain::AgreementLineId +pub fn radroots_domain::stock::AllocationClaim::new(radroots_domain::AgreementLineId, radroots_domain::PoolId, radroots_domain::Quantity, radroots_domain::Sequence) -> core::result::Result<Self, radroots_domain::stock::AllocationPlanError> +pub const fn radroots_domain::stock::AllocationClaim::pool_id(self) -> radroots_domain::PoolId +pub const fn radroots_domain::stock::AllocationClaim::quantity(self) -> radroots_domain::Quantity +impl core::fmt::Debug for radroots_domain::stock::AllocationClaim +pub fn radroots_domain::stock::AllocationClaim::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_domain::stock::OptionMappingKey impl radroots_domain::stock::OptionMappingKey pub const fn radroots_domain::stock::OptionMappingKey::listing(self) -> radroots_domain::listing::ListingCoordinate @@ -287,6 +332,16 @@ impl serde_core::ser::Serialize for radroots_domain::stock::PoolBalances pub fn radroots_domain::stock::PoolBalances::serialize<S: serde_core::ser::Serializer>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> impl<'de> serde_core::de::Deserialize<'de> for radroots_domain::stock::PoolBalances pub fn radroots_domain::stock::PoolBalances::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> +pub struct radroots_domain::stock::PoolHoldProposal +impl radroots_domain::stock::PoolHoldProposal +pub const fn radroots_domain::stock::PoolHoldProposal::after(self) -> radroots_domain::stock::PoolSnapshot +pub const fn radroots_domain::stock::PoolHoldProposal::before(self) -> radroots_domain::stock::PoolSnapshot +pub fn radroots_domain::stock::PoolHoldProposal::new(radroots_domain::stock::PoolSnapshot, radroots_domain::stock::StockTicks) -> core::result::Result<Self, radroots_domain::stock::AllocationPlanError> +pub const fn radroots_domain::stock::PoolHoldProposal::quantity(self) -> radroots_domain::stock::StockTicks +impl core::fmt::Debug for radroots_domain::stock::PoolHoldProposal +pub fn radroots_domain::stock::PoolHoldProposal::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl<'de> serde_core::de::Deserialize<'de> for radroots_domain::stock::PoolHoldProposal +pub fn radroots_domain::stock::PoolHoldProposal::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> pub struct radroots_domain::stock::PoolSnapshot impl radroots_domain::stock::PoolSnapshot pub const fn radroots_domain::stock::PoolSnapshot::balances(self) -> radroots_domain::stock::PoolBalances @@ -317,6 +372,16 @@ pub fn radroots_domain::stock::PoolView::new(&str, radroots_domain::stock::PoolS pub const fn radroots_domain::stock::PoolView::snapshot(&self) -> radroots_domain::stock::PoolSnapshot impl core::fmt::Debug for radroots_domain::stock::PoolView pub fn radroots_domain::stock::PoolView::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_domain::stock::StockAllocation +impl radroots_domain::stock::StockAllocation +pub const fn radroots_domain::stock::StockAllocation::line_id(self) -> radroots_domain::AgreementLineId +pub fn radroots_domain::stock::StockAllocation::new(radroots_domain::AgreementLineId, radroots_domain::PoolId, radroots_domain::stock::StockTicks) -> core::result::Result<Self, radroots_domain::stock::AllocationPlanError> +pub const fn radroots_domain::stock::StockAllocation::pool_id(self) -> radroots_domain::PoolId +pub const fn radroots_domain::stock::StockAllocation::ticks(self) -> radroots_domain::stock::StockTicks +impl core::fmt::Debug for radroots_domain::stock::StockAllocation +pub fn radroots_domain::stock::StockAllocation::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl<'de> serde_core::de::Deserialize<'de> for radroots_domain::stock::StockAllocation +pub fn radroots_domain::stock::StockAllocation::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> pub struct radroots_domain::stock::StockTicks(_) impl radroots_domain::stock::StockTicks pub const radroots_domain::stock::StockTicks::MAX: Self @@ -336,6 +401,7 @@ impl serde_core::ser::Serialize for radroots_domain::stock::StockTicks pub fn radroots_domain::stock::StockTicks::serialize<S: serde_core::ser::Serializer>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> impl<'de> serde_core::de::Deserialize<'de> for radroots_domain::stock::StockTicks pub fn radroots_domain::stock::StockTicks::deserialize<D: serde_core::de::Deserializer<'de>>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> +pub fn radroots_domain::stock::plan_allocations(&radroots_domain::Terms, &[radroots_domain::stock::OptionPoolMapping], &[radroots_domain::stock::PoolSnapshot], core::option::Option<&[radroots_domain::stock::AllocationClaim]>) -> core::result::Result<(alloc::vec::Vec<radroots_domain::stock::StockAllocation>, alloc::vec::Vec<radroots_domain::stock::PoolHoldProposal>), radroots_domain::stock::AllocationPlanError> #[non_exhaustive] pub enum radroots_domain::ActorRole pub radroots_domain::ActorRole::Buyer pub radroots_domain::ActorRole::Coordinator diff --git a/contracts/api_baselines/radroots_protocol.txt b/contracts/api_baselines/radroots_protocol.txt @@ -392,6 +392,14 @@ pub fn radroots_protocol::commerce::RecordWireError::from(radroots_protocol::ter impl core::error::Error for radroots_protocol::commerce::RecordWireError impl core::fmt::Display for radroots_protocol::commerce::RecordWireError pub fn radroots_protocol::commerce::RecordWireError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_protocol::commerce::CapturedCausalCoverage +impl radroots_protocol::commerce::CapturedCausalCoverage +pub const fn radroots_protocol::commerce::CapturedCausalCoverage::analysis(&self) -> &radroots_domain::commerce::causal::CausalAnalysis +pub fn radroots_protocol::commerce::CapturedCausalCoverage::capture(radroots_domain::commerce::causal::CausalScope, &[radroots_domain::commerce::causal::CausalRecord<'_>], &[radroots_domain::identifier::SourceId], &[radroots_domain::identifier::SourceId]) -> core::result::Result<Self, radroots_protocol::commerce::RecordWireError> +pub const fn radroots_protocol::commerce::CapturedCausalCoverage::checkpoint(&self) -> core::option::Option<&radroots_domain::context::CheckpointRef> +pub fn radroots_protocol::commerce::CapturedCausalCoverage::into_parts(self) -> (radroots_domain::commerce::causal::CausalAnalysis, core::option::Option<radroots_domain::context::CheckpointRef>) +impl core::fmt::Debug for radroots_protocol::commerce::CapturedCausalCoverage +pub fn radroots_protocol::commerce::CapturedCausalCoverage::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_protocol::commerce::DecodedRecord impl radroots_protocol::commerce::DecodedRecord pub fn radroots_protocol::commerce::DecodedRecord::check_rumor_fields(&self, radroots_identity::key::PublicKey, u64, u16) -> core::result::Result<(), radroots_protocol::commerce::RecordWireError> diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -368,6 +368,9 @@ pub use radroots_storage_sqlite::workspace::WorkspaceBinding pub use radroots_storage_sqlite::workspace::WorkspaceClock pub use radroots_storage_sqlite::workspace::WorkspaceError pub use radroots_storage_sqlite::workspace::WorkspaceScope +pub enum radroots_storage_sqlite::workspace::StockAcceptanceOutcome +pub radroots_storage_sqlite::workspace::StockAcceptanceOutcome::Prepared(alloc::boxed::Box<radroots_storage_sqlite::workspace::StockAcceptanceReceipt>) +pub radroots_storage_sqlite::workspace::StockAcceptanceOutcome::Unknown(radroots_storage::command::CommitAttempt) pub enum radroots_storage_sqlite::workspace::StockConsentMode pub radroots_storage_sqlite::workspace::StockConsentMode::ExecuteAndRecover pub radroots_storage_sqlite::workspace::StockConsentMode::RecoverOnly @@ -413,12 +416,15 @@ impl radroots_storage_sqlite::workspace::NativeWorkspace pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::issue_stock_consent(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, &radroots_storage_sqlite::workspace::StockConsentCapture, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockConsentOutcome, radroots_storage::command::OperationError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_consent(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::GrantId, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage_sqlite::workspace::StockConsentReceipt>, radroots_storage::command::OperationError> impl radroots_storage_sqlite::workspace::NativeWorkspace +pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::prepare_stock_acceptance(&self, radroots_storage_sqlite::workspace::StockAcceptanceRequest, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockAcceptanceOutcome, radroots_storage::command::OperationError> +impl radroots_storage_sqlite::workspace::NativeWorkspace pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::retain_stock_listing(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, &radroots_storage_sqlite::workspace::StockListingCapture, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockListingOutcome, radroots_storage::command::OperationError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_listing_head(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_domain::listing::reference::ListingCoordinate, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage_sqlite::workspace::StockListingSnapshot>, radroots_storage::command::OperationError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_listing_source(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_domain::listing::reference::ListingRevision, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage_sqlite::workspace::StockListingSnapshot>, radroots_storage::command::OperationError> impl radroots_storage_sqlite::workspace::NativeWorkspace pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::retain_stock_source(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, &radroots_storage_sqlite::workspace::StockSourceCapture, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockSourceOutcome, radroots_storage::command::OperationError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_order_history(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_domain::commerce::causal::CausalScope, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockHistorySnapshot, radroots_storage::command::OperationError> +pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_order_request(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, radroots_domain::identifier::RecordId, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockRequestSnapshot, radroots_storage::command::OperationError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_source(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_domain::identifier::EnvelopeEventId, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage_sqlite::workspace::StockSourceSnapshot>, radroots_storage::command::OperationError> impl core::fmt::Debug for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -446,6 +452,24 @@ pub fn radroots_storage_sqlite::workspace::NativeWorkspace::pool(&self, radroots impl radroots_storage::workspace::WorkspaceStore for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::close_workspace(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<(), radroots_storage::workspace::WorkspaceError>> +pub struct radroots_storage_sqlite::workspace::StockAcceptanceReceipt +impl radroots_storage_sqlite::workspace::StockAcceptanceReceipt +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::allocation_count(&self) -> usize +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::first_issue_deadline(&self) -> radroots_domain::context::UnixSeconds +pub fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::held_pools(&self) -> &[radroots_domain::stock::PoolSnapshot] +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::order_id(&self) -> radroots_domain::identifier::OrderId +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::prepared_at(&self) -> radroots_domain::context::UnixSeconds +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::request(&self) -> radroots_domain::identifier::RecordId +pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::terms_digest(&self) -> radroots_domain::identifier::TermsDigest +impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockAcceptanceReceipt +pub fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage_sqlite::workspace::StockAcceptanceRequest +impl radroots_storage_sqlite::workspace::StockAcceptanceRequest +pub fn radroots_storage_sqlite::workspace::StockAcceptanceRequest::capture(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef, radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef, &radroots_protocol::command::order_acceptance::CapturedOrderAcceptance) -> core::result::Result<Self, radroots_storage::command::OperationError> +impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockAcceptanceRequest +pub fn radroots_storage_sqlite::workspace::StockAcceptanceRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage_sqlite::workspace::StockAuthorityReceipt impl radroots_storage_sqlite::workspace::StockAuthorityReceipt pub fn radroots_storage_sqlite::workspace::StockAuthorityReceipt::input(&self) -> &radroots_storage::workspace::AttachmentInput @@ -502,6 +526,7 @@ pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::transaction_ pub struct radroots_storage_sqlite::workspace::StockHistorySnapshot impl radroots_storage_sqlite::workspace::StockHistorySnapshot pub const fn radroots_storage_sqlite::workspace::StockHistorySnapshot::analysis(&self) -> &radroots_domain::commerce::causal::CausalAnalysis +pub fn radroots_storage_sqlite::workspace::StockHistorySnapshot::checkpoint(&self) -> core::option::Option<&radroots_domain::context::CheckpointRef> pub const fn radroots_storage_sqlite::workspace::StockHistorySnapshot::known_records(&self) -> usize pub const fn radroots_storage_sqlite::workspace::StockHistorySnapshot::listing_checkpoint(&self) -> radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef pub const fn radroots_storage_sqlite::workspace::StockHistorySnapshot::observed_at(&self) -> radroots_domain::context::UnixSeconds @@ -532,6 +557,20 @@ pub const fn radroots_storage_sqlite::workspace::StockListingSnapshot::receipt(& pub const fn radroots_storage_sqlite::workspace::StockListingSnapshot::selection_checkpoint(&self) -> radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockListingSnapshot pub fn radroots_storage_sqlite::workspace::StockListingSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage_sqlite::workspace::StockRequestSnapshot +impl radroots_storage_sqlite::workspace::StockRequestSnapshot +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::checkpoint(&self) -> &radroots_domain::context::CheckpointRef +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::expires_at(&self) -> radroots_domain::context::UnixSeconds +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::listing_checkpoint(&self) -> radroots_storage::workspace::seller_stock::source::StockListingCheckpointRef +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::observed_at(&self) -> radroots_domain::context::UnixSeconds +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::quote(&self) -> core::option::Option<radroots_domain::identifier::RecordId> +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::request(&self) -> radroots_domain::identifier::RecordId +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::scope(&self) -> radroots_domain::commerce::causal::CausalScope +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::source_checkpoint(&self) -> radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef +pub fn radroots_storage_sqlite::workspace::StockRequestSnapshot::terms(&self) -> &radroots_domain::agreement::Terms +pub const fn radroots_storage_sqlite::workspace::StockRequestSnapshot::terms_digest(&self) -> radroots_domain::identifier::TermsDigest +impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockRequestSnapshot +pub fn radroots_storage_sqlite::workspace::StockRequestSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage_sqlite::workspace::StockSourceCapture impl radroots_storage_sqlite::workspace::StockSourceCapture pub const fn radroots_storage_sqlite::workspace::StockSourceCapture::envelope_id(&self) -> radroots_domain::identifier::EnvelopeEventId diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -75,7 +75,7 @@ "scope": "seller_stock_owner", "database": "stock_execution_v1.sqlite", "lock": ".stock_execution_v1.lock", - "schema_version": 8, + "schema_version": 9, "retained_enrollment_versions": [ 1 ], @@ -85,9 +85,10 @@ 4, 5, 6, - 7 + 7, + 8 ], - "authority_payload_schema": "radroots.seller_stock.authority.v8", + "authority_payload_schema": "radroots.seller_stock.authority.v9", "public_source_payload_schemas": [ "radroots.seller_stock.public_source_event.v1", "radroots.seller_stock.public_source_head.v1", @@ -112,6 +113,23 @@ "operation_part_max_bytes": 16384, "operation_part_max_count": 16, "operation_identity_requires_protected_ancestry": true, + "acceptance_preparation": { + "payload_version": 1, + "planner_owner": "radroots_domain", + "order_payload_schema": "radroots.seller_stock.order.v1", + "movement_payload_schema": "radroots.seller_stock.acceptance_movement.v1", + "worker_charge_bytes": 524288, + "max_allocations": 64, + "max_pool_observations": 96, + "max_first_issue_window_seconds": 120, + "original_replay_before_fresh_planning": true, + "complete_allocation_required": true, + "atomic_holds_and_order_fence_required": true, + "current_issued_consent_required": true, + "final_source_counts_and_witnesses_required": true, + "signer_invoked": false, + "agreement_installed": false + }, "business_consent_payload_version": 1, "business_consent_action": "orders.accept", "business_consent_modes": ["execute_and_recover", "recover_only"], diff --git a/crates/domain/src/commerce/causal.rs b/crates/domain/src/commerce/causal.rs @@ -10,6 +10,8 @@ use alloc::{ vec::Vec, }; use core::fmt; +mod request; +pub use request::{InitialRequestClaim, RequestClaimError, prepare_initial_request}; /// One exact bilateral order scope, including seller quotes in its null-order /// author chain. The scope itself is untrusted data, not evidence coverage. @@ -73,6 +75,14 @@ pub struct CausalRecord<'a> { content: &'a CommerceContent, } impl<'a> CausalRecord<'a> { + /// Returns the asserted identity, without checking its canonical hash. + pub const fn record_id(self) -> RecordId { + self.id + } + /// Borrows the original complete content claim without authenticating it. + pub const fn content(self) -> &'a CommerceContent { + self.content + } /// Borrows the complete content so duplicate identity comparisons cannot /// accidentally ignore a changed payload. No source bytes are copied. pub const fn new(id: RecordId, content: &'a CommerceContent) -> Self { diff --git a/crates/domain/src/commerce/causal/request.rs b/crates/domain/src/commerce/causal/request.rs @@ -0,0 +1,187 @@ +//! Initial request claims only. Concrete adapters must authenticate complete +//! coverage, current public/quote source permission and actual execution rights. +use super::*; +use crate::{CommercePayload, Terms, TermsRequest, UnixSeconds}; + +/// Borrowed complete request data after self-contained local causal/time checks. +/// This value supplies no signature, current-source or execution capability. +pub struct InitialRequestClaim<'a> { + request: RecordId, + terms: &'a Terms, + expires: UnixSeconds, + quote: Option<RecordId>, +} +impl InitialRequestClaim<'_> { + /// Exact selected request claim; original carrier authentication is separate. + pub const fn request(&self) -> RecordId { + self.request + } + /// Complete private terms claim; no stock is acquired by borrowing it. + pub const fn terms(&self) -> &Terms { + self.terms + } + /// Earliest current request/explicit-quote deadline, excluding execution scope. + pub const fn expires_at(&self) -> UnixSeconds { + self.expires + } + /// Exact optional seller quote whose complete terms equal this request. + pub const fn quote(&self) -> Option<RecordId> { + self.quote + } +} +impl fmt::Debug for InitialRequestClaim<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("InitialRequestClaim(<private data>)") + } +} +/// Bounded initial-request claim failures, without private source values. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[non_exhaustive] +pub enum RequestClaimError { + /// Source count or identity/scope declarations are invalid. + InvalidGraph, + /// Required original parents or the selected request are absent. + MissingHistory, + /// The known scoped graph contains an incompatible author fork or cycle. + Conflicted, + /// Authenticated uninterpreted evidence prevents a complete local reduction. + Uninterpreted, + /// The selected record is not a buyer request in this exact scope. + WrongRequest, + /// The request or exact quote no longer admits a fresh decision. + Expired, + /// Known scoped author time is ahead of the supplied usable observation. + ClockAhead, + /// An observed buyer withdrawal names the selected authorization. + Withdrawn, + /// An observed seller decline names the selected request. + Declined, + /// The exact quoted record has another family or different complete terms. + QuoteMismatch, + /// Another unexpired unretracted buyer request authorizes incompatible terms. + ConflictingAuthorizations, + /// Advanced agreement/negotiation state needs its corresponding operation. + RequiresReconciliation, +} +impl fmt::Display for RequestClaimError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::InvalidGraph => "invalid initial request graph", + Self::MissingHistory => "initial request history missing", + Self::Conflicted => "initial request history conflicted", + Self::Uninterpreted => "initial request history uninterpreted", + Self::WrongRequest => "wrong initial request", + Self::Expired => "initial request deadline expired", + Self::ClockAhead => "initial request clock observation insufficient", + Self::Withdrawn => "initial request withdrawn", + Self::Declined => "initial request declined", + Self::QuoteMismatch => "initial request quote differs", + Self::ConflictingAuthorizations => "initial request authorizations conflict", + Self::RequiresReconciliation => "initial request state needs reconciliation", + }) + } +} +impl core::error::Error for RequestClaimError {} +fn deadline( + request: &TermsRequest, + records: &[CausalRecord<'_>], +) -> Result<UnixSeconds, RequestClaimError> { + let mut expires = request.expires_at(); + if let Some(id) = request.quote() { + let quoted = records + .iter() + .find(|record| record.id == id) + .ok_or(RequestClaimError::MissingHistory)?; + let CommercePayload::Quote(quote) = quoted.content.payload() else { + return Err(RequestClaimError::QuoteMismatch); + }; + if quote.terms() != request.terms() { + return Err(RequestClaimError::QuoteMismatch); + } + expires = expires.min(quote.expires_at()); + } + Ok(expires) +} + +/// Prepares only an initial quote/request/decline/withdrawal claim. Broader +/// negotiation and installed agreement records require their own stateful +/// operation; they are preserved, never treated as an empty initial order. +/// An original retained operation must be recovered before calling this fresh +/// planner. Neither expiry nor withdrawal erases an already admitted operation. +pub fn prepare_initial_request<'a>( + scope: CausalScope, + selected: RecordId, + records: &[CausalRecord<'a>], + external: &[SourceId], + uninterpreted: &[SourceId], + observed_at: UnixSeconds, +) -> Result<InitialRequestClaim<'a>, RequestClaimError> { + let analysis = analyze(scope, records, external, uninterpreted) + .map_err(|_| RequestClaimError::InvalidGraph)?; + match analysis.readiness() { + CausalReadiness::Complete => {} + CausalReadiness::MissingHistory => return Err(RequestClaimError::MissingHistory), + CausalReadiness::Conflicted => return Err(RequestClaimError::Conflicted), + CausalReadiness::Uninterpreted => return Err(RequestClaimError::Uninterpreted), + } + let selected_content = records + .iter() + .find(|record| record.id == selected) + .ok_or(RequestClaimError::MissingHistory)? + .content; + let CommercePayload::Request(request) = selected_content.payload() else { + return Err(RequestClaimError::WrongRequest); + }; + if selected_content.header().order_id() != Some(scope.order) + || selected_content.header().author() != scope.buyer + { + return Err(RequestClaimError::WrongRequest); + } + if records + .iter() + .any(|record| record.content.header().created_at() > observed_at) + { + return Err(RequestClaimError::ClockAhead); + } + let expires = deadline(request, records)?; + if expires <= observed_at { + return Err(RequestClaimError::Expired); + } + let withdrawn = |id| { + records.iter().any(|record|matches!(record.content.payload(),CommercePayload::WithdrawalRequested(value) if value.target()==id)) + }; + let declined = |id| { + records.iter().any(|record|matches!(record.content.payload(),CommercePayload::Decline(value) if value.target()==id)) + }; + if withdrawn(selected) { + return Err(RequestClaimError::Withdrawn); + } + if declined(selected) { + return Err(RequestClaimError::Declined); + } + for record in records { + match record.content.payload() { + CommercePayload::Request(other) => { + let other_expires = deadline(other, records)?; + if record.id != selected + && other_expires > observed_at + && !withdrawn(record.id) + && !declined(record.id) + && other.terms() != request.terms() + { + return Err(RequestClaimError::ConflictingAuthorizations); + } + } + CommercePayload::Quote(_) + | CommercePayload::Decline(_) + | CommercePayload::WithdrawalRequested(_) => {} + _ => return Err(RequestClaimError::RequiresReconciliation), + } + } + Ok(InitialRequestClaim { + request: selected, + terms: request.terms(), + expires, + quote: request.quote(), + }) +} diff --git a/crates/domain/src/listing.rs b/crates/domain/src/listing.rs @@ -590,6 +590,10 @@ impl ListingTerms { pub const fn state(&self) -> ListingState { self.state } + /// Borrows the exact public product snapshot without any live source proof. + pub const fn product(&self) -> &Product { + &self.product + } /// Borrows the bounded, unique public choices. pub fn options(&self) -> &[ListingOption] { &self.options diff --git a/crates/domain/src/stock.rs b/crates/domain/src/stock.rs @@ -3,7 +3,11 @@ use crate::{PoolId, Quantity, Sequence, listing::MeasurementUnit}; use core::{fmt, str::FromStr}; +mod allocation; mod mapping; +pub use allocation::{ + AllocationClaim, AllocationPlanError, PoolHoldProposal, StockAllocation, plan_allocations, +}; pub use mapping::{MappingError, OptionMappingKey, OptionPoolMapping}; /// A bounded, input-free stock value failure. diff --git a/crates/domain/src/stock/allocation.rs b/crates/domain/src/stock/allocation.rs @@ -0,0 +1,333 @@ +//! Portable complete stock-allocation proposals. These are unauthenticated +//! values; only a qualified executor can acquire actual stock in a transaction. +use super::{OptionMappingKey, OptionPoolMapping, PoolSnapshot, StockTicks}; +use crate::{AgreementLineId, AgreementPrice, PoolId, Quantity, Sequence, SupplyCommitment, Terms}; +use alloc::{collections::BTreeMap, vec, vec::Vec}; +use core::fmt; + +/// A positive seller allocation claim before current pool/version validation. +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct AllocationClaim { + line: AgreementLineId, + pool: PoolId, + quantity: Quantity, + expected: Sequence, +} +impl AllocationClaim { + /// Captures data only; no participant, mapping or stock is authenticated. + pub fn new( + line: AgreementLineId, + pool: PoolId, + quantity: Quantity, + expected: Sequence, + ) -> Result<Self, AllocationPlanError> { + if quantity.amount().is_zero() || expected.get() == 0 { + return Err(AllocationPlanError::InvalidInput); + } + Ok(Self { + line, + pool, + quantity, + expected, + }) + } + /// Exact claimed agreement line. + pub const fn line_id(self) -> AgreementLineId { + self.line + } + /// Exact claimed private pool. + pub const fn pool_id(self) -> PoolId { + self.pool + } + /// Explicit positive quantity with its declared unit. + pub const fn quantity(self) -> Quantity { + self.quantity + } + /// Positive expected current pool version. + pub const fn expected_pool_version(self) -> Sequence { + self.expected + } +} +/// Exact positive proposed line/pool draw, without a store hold or consent. +#[derive(Clone, Copy, Eq, PartialEq)] +#[cfg_attr(feature = "serde", derive(serde::Serialize))] +pub struct StockAllocation { + line: AgreementLineId, + pool: PoolId, + ticks: StockTicks, +} +impl StockAllocation { + /// Captures only a positive proposed draw. Execution is always separate. + pub fn new( + line: AgreementLineId, + pool: PoolId, + ticks: StockTicks, + ) -> Result<Self, AllocationPlanError> { + if ticks == StockTicks::ZERO { + return Err(AllocationPlanError::InvalidInput); + } + Ok(Self { line, pool, ticks }) + } + /// Exact proposed line identity. + pub const fn line_id(self) -> AgreementLineId { + self.line + } + /// Exact proposed private pool identity. + pub const fn pool_id(self) -> PoolId { + self.pool + } + /// Exact positive pool ticks to acquire. + pub const fn ticks(self) -> StockTicks { + self.ticks + } +} +/// Conservation-checked before/after data; construction never acquires stock. +#[derive(Clone, Copy, Eq, PartialEq)] +#[cfg_attr(feature = "serde", derive(serde::Serialize))] +pub struct PoolHoldProposal { + before: PoolSnapshot, + after: PoolSnapshot, + quantity: StockTicks, +} +impl PoolHoldProposal { + /// Proposes available-to-preparatory transfer and one positive version step. + pub fn new(before: PoolSnapshot, quantity: StockTicks) -> Result<Self, AllocationPlanError> { + if before.version().get() == 0 || quantity == StockTicks::ZERO { + return Err(AllocationPlanError::InvalidInput); + } + let balances = before + .balances() + .hold_available(quantity) + .map_err(|_| AllocationPlanError::StaleState)?; + let version = Sequence::new( + before + .version() + .get() + .checked_add(1) + .ok_or(AllocationPlanError::Capacity)?, + ) + .map_err(|_| AllocationPlanError::Capacity)?; + Ok(Self { + before, + after: PoolSnapshot::new(before.id(), before.unit(), balances, version), + quantity, + }) + } + /// Exact observed data claim before the proposed transfer. + pub const fn before(self) -> PoolSnapshot { + self.before + } + /// Exact proposed after-image, not a confirmed database state. + pub const fn after(self) -> PoolSnapshot { + self.after + } + /// Positive quantity proposed for preparatory backing. + pub const fn quantity(self) -> StockTicks { + self.quantity + } +} +/// Input-free complete-allocation failure; no source or private values retained. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[non_exhaustive] +pub enum AllocationPlanError { + /// Missing, ambiguous, incompatible, inexact or incomplete allocation data. + InvalidInput, + /// A supplied current version/unit or available quantity cannot support it. + StaleState, + /// A future supply or price profile is not supported. + Unsupported, + /// Exact quantity, aggregate, collection or version capacity is exceeded. + Capacity, +} +impl fmt::Display for AllocationPlanError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::InvalidInput => "invalid complete allocation", + Self::StaleState => "allocation state differs", + Self::Unsupported => "unsupported allocation profile", + Self::Capacity => "allocation capacity exceeded", + }) + } +} +impl core::error::Error for AllocationPlanError {} +macro_rules! redacted { ($($name:ident),+) => { $(impl fmt::Debug for $name { fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result { f.write_str(concat!(stringify!($name),"(<private proposal>)")) } })+ }; } +redacted!(AllocationClaim, StockAllocation, PoolHoldProposal); + +#[cfg(feature = "serde")] +mod serialization { + use super::*; + use serde::Deserialize; + impl<'de> Deserialize<'de> for StockAllocation { + fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Wire { + line: AgreementLineId, + pool: PoolId, + ticks: StockTicks, + } + let wire: Wire = super::super::serialization::object(deserializer)?; + Self::new(wire.line, wire.pool, wire.ticks).map_err(serde::de::Error::custom) + } + } + impl<'de> Deserialize<'de> for PoolHoldProposal { + fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Wire { + before: PoolSnapshot, + after: PoolSnapshot, + quantity: StockTicks, + } + let wire: Wire = super::super::serialization::object(deserializer)?; + let value = Self::new(wire.before, wire.quantity).map_err(serde::de::Error::custom)?; + if value.after != wire.after { + return Err(serde::de::Error::custom("pool hold proposal differs")); + } + Ok(value) + } + } +} + +/// Resolves complete deterministic allocation data with checked exact units and +/// versioned before/after proposals. `None` selects current mappings; `Some` +/// requires one through64 distinct positive line/pool claims with complete line +/// coverage. At most96 distinct pool observations are accepted. Only explicit +/// future-promise terms allow no physical draws. This function performs no IO, +/// authenticates no source/grant/version and acquires no stock. +pub fn plan_allocations( + terms: &Terms, + mappings: &[OptionPoolMapping], + pools: &[PoolSnapshot], + explicit: Option<&[AllocationClaim]>, +) -> Result<(Vec<StockAllocation>, Vec<PoolHoldProposal>), AllocationPlanError> { + match terms.supply() { + SupplyCommitment::FuturePromise(_) => { + if explicit.is_some() || !mappings.is_empty() || !pools.is_empty() { + return Err(AllocationPlanError::InvalidInput); + } + return Ok((vec![], vec![])); + } + SupplyCommitment::StockBacked => {} + } + if mappings.len() != terms.lines().len() || pools.len() > 96 { + return Err(AllocationPlanError::InvalidInput); + } + if let Some(choices) = explicit { + if choices.is_empty() || choices.len() > 64 { + return Err(AllocationPlanError::InvalidInput); + } + for (index, choice) in choices.iter().enumerate() { + if choices[..index] + .iter() + .any(|prior| prior.line == choice.line && prior.pool == choice.pool) + { + return Err(AllocationPlanError::InvalidInput); + } + } + } + let mut available = BTreeMap::new(); + for pool in pools { + if pool.version().get() == 0 || available.insert(pool.id(), *pool).is_some() { + return Err(AllocationPlanError::InvalidInput); + } + } + let mut result = Vec::new(); + for (line, mapping) in terms.lines().iter().zip(mappings) { + if mapping.key() != OptionMappingKey::new(line.source().coordinate(), line.option_id()) + || available + .get(&mapping.pool_id()) + .is_none_or(|pool| pool.unit() != mapping.pool_unit()) + { + return Err(AllocationPlanError::StaleState); + } + let required = match line.price() { + AgreementPrice::Fixed(_) => mapping + .draw_for_sales(line.amount()) + .map_err(|_| AllocationPlanError::InvalidInput)?, + AgreementPrice::VariableWeight(weight) => { + // Bounds describe this entire line. Never multiply by package + // count or infer a mass/volume conversion from its label. + let quantity = Quantity::new(weight.maximum().amount(), weight.measurement_unit()) + .and_then(|value| value.convert(mapping.pool_unit().unit())) + .map_err(|_| AllocationPlanError::InvalidInput)?; + mapping + .pool_unit() + .ticks_for(quantity) + .map_err(|_| AllocationPlanError::InvalidInput)? + } + }; + if required == StockTicks::ZERO { + return Err(AllocationPlanError::InvalidInput); + } + if let Some(explicit) = explicit { + let mut covered = StockTicks::ZERO; + for choice in explicit.iter().filter(|value| value.line_id() == line.id()) { + let pool = available + .get(&choice.pool_id()) + .ok_or(AllocationPlanError::StaleState)?; + if pool.version() != choice.expected_pool_version() { + return Err(AllocationPlanError::StaleState); + } + let normalized = choice + .quantity() + .convert(mapping.pool_unit().unit()) + .map_err(|_| AllocationPlanError::InvalidInput)?; + covered = covered + .checked_add( + mapping + .pool_unit() + .ticks_for(normalized) + .map_err(|_| AllocationPlanError::InvalidInput)?, + ) + .map_err(|_| AllocationPlanError::Capacity)?; + let quantity = choice + .quantity() + .convert(pool.unit().unit()) + .map_err(|_| AllocationPlanError::InvalidInput)?; + let ticks = pool + .unit() + .ticks_for(quantity) + .map_err(|_| AllocationPlanError::InvalidInput)?; + result.push(StockAllocation { + line: line.id(), + pool: pool.id(), + ticks, + }); + } + if covered != required { + return Err(AllocationPlanError::InvalidInput); + } + } else { + result.push(StockAllocation { + line: line.id(), + pool: mapping.pool_id(), + ticks: required, + }); + } + } + if let Some(explicit) = explicit + && result.len() != explicit.len() + { + return Err(AllocationPlanError::InvalidInput); + } + if result.is_empty() || result.len() > 64 { + return Err(AllocationPlanError::InvalidInput); + } + result.sort_by_key(|value| (value.pool, value.line)); + let mut totals = BTreeMap::new(); + for allocation in &result { + if allocation.ticks == StockTicks::ZERO { + return Err(AllocationPlanError::InvalidInput); + } + let total = totals.entry(allocation.pool).or_insert(StockTicks::ZERO); + *total = total + .checked_add(allocation.ticks) + .map_err(|_| AllocationPlanError::Capacity)?; + } + let mut effects = Vec::new(); + for (id, quantity) in totals { + effects.push(PoolHoldProposal::new(available[&id], quantity)?); + } + Ok((result, effects)) +} diff --git a/crates/domain/tests/stock_allocation.rs b/crates/domain/tests/stock_allocation.rs @@ -0,0 +1,123 @@ +use radroots_domain::{ + AgreementLineId, PoolId, Quantity, Sequence, listing::MeasurementUnit, stock::*, +}; + +fn ticks(value: u64) -> StockTicks { + StockTicks::new(value).unwrap() +} +fn pool(version: u64) -> PoolSnapshot { + PoolSnapshot::new( + PoolId::from_bytes([1; 32]), + PoolUnit::new(MeasurementUnit::Each, 0).unwrap(), + PoolBalances::new( + ticks(10), + PhysicalBalances { + available: ticks(10), + ..PhysicalBalances::ZERO + }, + ) + .unwrap(), + Sequence::new(version).unwrap(), + ) +} +#[test] +fn positive_proposals_are_data_and_reject_missing_versions_or_unavailable_backing() { + let before = pool(1); + let proposal = PoolHoldProposal::new(before, ticks(3)).unwrap(); + assert_eq!(proposal.before(), before); + assert_eq!(proposal.after().balances().physical().available, ticks(7)); + assert_eq!( + proposal.after().balances().physical().preparatory_hold, + ticks(3) + ); + assert_eq!(proposal.after().version().get(), 2); + assert_eq!(proposal.after().balances().introduced(), ticks(10)); + assert_eq!( + PoolHoldProposal::new(before, ticks(11)), + Err(AllocationPlanError::StaleState) + ); + assert_eq!( + PoolHoldProposal::new(before, StockTicks::ZERO), + Err(AllocationPlanError::InvalidInput) + ); + assert_eq!( + PoolHoldProposal::new(pool(0), ticks(1)), + Err(AllocationPlanError::InvalidInput) + ); + let quantity = Quantity::new("1".parse().unwrap(), MeasurementUnit::Each).unwrap(); + assert!( + AllocationClaim::new( + AgreementLineId::from_bytes([2; 32]), + before.id(), + quantity, + Sequence::new(0).unwrap() + ) + .is_err() + ); + assert!( + StockAllocation::new( + AgreementLineId::from_bytes([2; 32]), + before.id(), + StockTicks::ZERO + ) + .is_err() + ); + assert_eq!( + format!("{proposal:?}"), + "PoolHoldProposal(<private proposal>)" + ); +} +#[cfg(feature = "serde")] +#[test] +fn restored_hold_proposal_must_recompute_the_entire_after_image() { + let proposal = PoolHoldProposal::new(pool(1), ticks(3)).unwrap(); + let original = serde_json::to_value(proposal).unwrap(); + let restored: PoolHoldProposal = serde_json::from_value(original.clone()).unwrap(); + assert_eq!(restored, proposal); + for path in ["/after/version", "/after/id"] { + let mut changed = original.clone(); + if path.ends_with("version") { + *changed.pointer_mut(path).unwrap() = serde_json::json!("3"); + } else { + *changed.pointer_mut(path).unwrap() = serde_json::json!("ab".repeat(32)); + } + assert!( + serde_json::from_value::<PoolHoldProposal>(changed).is_err(), + "{path}" + ); + } + let mut changed = original.clone(); + changed["quantity"] = serde_json::json!("2"); + assert!(serde_json::from_value::<PoolHoldProposal>(changed).is_err()); + let mut changed = original; + changed["unexpected"] = serde_json::json!(true); + assert!(serde_json::from_value::<PoolHoldProposal>(changed).is_err()); +} +#[cfg(feature = "serde")] +#[test] +fn restored_allocations_cannot_create_zero_draws_or_ambiguous_objects() { + let allocation = StockAllocation::new( + AgreementLineId::from_bytes([2; 32]), + PoolId::from_bytes([1; 32]), + ticks(3), + ) + .unwrap(); + let original = serde_json::to_value(allocation).unwrap(); + assert_eq!( + serde_json::from_value::<StockAllocation>(original.clone()).unwrap(), + allocation + ); + let mut changed = original.clone(); + changed["ticks"] = serde_json::json!("0"); + assert!(serde_json::from_value::<StockAllocation>(changed).is_err()); + let mut changed = original; + changed["unexpected"] = serde_json::json!(true); + assert!(serde_json::from_value::<StockAllocation>(changed).is_err()); + let duplicate = format!( + "{{\"line\":\"{}\",\"line\":\"{}\",\"pool\":\"{}\",\"ticks\":\"3\"}}", + allocation.line_id(), + allocation.line_id(), + allocation.pool_id() + ); + assert!(serde_json::from_str::<StockAllocation>(&duplicate).is_err()); +} diff --git a/crates/protocol/src/commerce.rs b/crates/protocol/src/commerce.rs @@ -10,7 +10,9 @@ use radroots_domain::{CommerceContent, PublicKey, RecordId}; use sha2::{Digest as _, Sha256}; use zeroize::Zeroizing; +mod coverage; mod decode; +pub use coverage::CapturedCausalCoverage; mod payload; pub use decode::{DecodedRecord, decode}; mod rumor; diff --git a/crates/protocol/src/commerce/coverage.rs b/crates/protocol/src/commerce/coverage.rs @@ -0,0 +1,102 @@ +//! Exact portable local coverage data. Neither a digest nor a complete supplied +//! graph proves authentic store coverage, participant permission or order state. +use super::{EncodedRecord, RecordWireError}; +use alloc::{collections::BTreeSet, vec::Vec}; +use core::fmt; +use radroots_domain::{ + CheckpointDigest, CheckpointRef, Coverage, Sequence, SourceId, + causal::{self, CausalAnalysis, CausalRecord, CausalScope}, +}; +use sha2::{Digest, Sha256}; + +/// Checked canonical identity/graph data and an optional complete local scope +/// descriptor. Constructors never grant read, execute, signer or stock rights. +pub struct CapturedCausalCoverage { + analysis: CausalAnalysis, + checkpoint: Option<CheckpointRef>, +} +impl CapturedCausalCoverage { + /// Checks every complete canonical record identity before deriving the + /// descriptor. External identities and completeness are still caller claims; + /// concrete stores must independently authenticate them and their coverage. + pub fn capture( + scope: CausalScope, + records: &[CausalRecord<'_>], + external: &[SourceId], + uninterpreted: &[SourceId], + ) -> Result<Self, RecordWireError> { + let analysis = causal::analyze(scope, records, external, uninterpreted).map_err( + |error| match error { + causal::CausalError::LimitExceeded => RecordWireError::LimitExceeded, + causal::CausalError::IdentityConflict => RecordWireError::IdentityMismatch, + _ => RecordWireError::InvalidInput, + }, + )?; + let mut known = BTreeSet::new(); + let mut required = BTreeSet::<SourceId>::new(); + for record in records { + if EncodedRecord::capture(record.content())?.record_id() != record.record_id() { + return Err(RecordWireError::IdentityMismatch); + } + known.insert(SourceId::from_bytes(record.record_id().into_bytes())); + required.extend(record.content().header().parents().iter().copied()); + } + let checkpoint = if analysis.readiness() == causal::CausalReadiness::Complete { + let external: BTreeSet<_> = external + .iter() + .copied() + .filter(|id| required.contains(id) && !known.contains(id)) + .collect(); + let barriers: BTreeSet<_> = uninterpreted.iter().copied().collect(); + let mut hash = Sha256::new(); + hash.update(b"radroots.commerce.coverage.v1\0"); + // Fixed-width scope fields, then three length-prefixed sorted sets. + // No host word size, JSON map ordering or transport encoding enters + // this transcript. Public record IDs commit complete content. + hash.update(scope.thread_id().as_bytes()); + hash.update(scope.order_id().as_bytes()); + hash.update(scope.buyer().as_bytes()); + hash.update(scope.seller().as_bytes()); + for identities in [&known, &external, &barriers] { + hash.update((identities.len() as u64).to_be_bytes()); + for id in identities { + hash.update(id.as_bytes()); + } + } + let sequence = Sequence::new((known.len() + external.len() + barriers.len()) as u64) + .map_err(|_| RecordWireError::LimitExceeded)?; + Some( + CheckpointRef::new( + CheckpointDigest::from_bytes(hash.finalize().into()), + sequence, + Coverage::ScopeSatisfied, + Vec::new(), + ) + .map_err(|_| RecordWireError::InvalidInput)?, + ) + } else { + None + }; + Ok(Self { + analysis, + checkpoint, + }) + } + /// Borrows exact known gaps/forks and local causal classification. + pub const fn analysis(&self) -> &CausalAnalysis { + &self.analysis + } + /// Returns a complete supplied scope descriptor; it grants no permission. + pub const fn checkpoint(&self) -> Option<&CheckpointRef> { + self.checkpoint.as_ref() + } + /// Moves the checked data without promoting it to authenticated evidence. + pub fn into_parts(self) -> (CausalAnalysis, Option<CheckpointRef>) { + (self.analysis, self.checkpoint) + } +} +impl fmt::Debug for CapturedCausalCoverage { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("CapturedCausalCoverage(<local coverage claims>)") + } +} diff --git a/crates/protocol/tests/commerce_coverage.rs b/crates/protocol/tests/commerce_coverage.rs @@ -0,0 +1,267 @@ +#![cfg(feature = "commerce")] +use radroots_domain::{causal::*, *}; +use radroots_protocol::commerce::{CapturedCausalCoverage, DecodedRecord, RecordWireError, decode}; +use serde_json::Value; +use std::collections::BTreeMap; + +fn fixture() -> Value { + serde_json::from_str(include_str!("fixtures/commerce_coverage.v1.json")).unwrap() +} +fn scope(value: &Value) -> CausalScope { + CausalScope::new( + value["thread"].as_str().unwrap().parse().unwrap(), + value["order"].as_str().unwrap().parse().unwrap(), + value["buyer"].as_str().unwrap().parse().unwrap(), + value["seller"].as_str().unwrap().parse().unwrap(), + ) + .unwrap() +} +fn records(value: &Value) -> BTreeMap<String, DecodedRecord> { + value["records"] + .as_object() + .unwrap() + .iter() + .map(|(name, row)| { + ( + name.clone(), + decode(row["wire"].as_str().unwrap().as_bytes()).unwrap(), + ) + }) + .collect() +} +fn ids(value: &Value) -> Vec<SourceId> { + value + .as_array() + .unwrap() + .iter() + .map(|id| id.as_str().unwrap().parse().unwrap()) + .collect() +} +fn readiness(value: CausalReadiness) -> &'static str { + match value { + CausalReadiness::Complete => "complete", + CausalReadiness::MissingHistory => "missing_history", + CausalReadiness::Conflicted => "conflicted", + CausalReadiness::Uninterpreted => "uninterpreted", + } +} + +#[test] +fn independent_fixed_width_scope_transcripts_match_complete_graphs_without_transport_churn() { + let fixture = fixture(); + let decoded = records(&fixture); + let scope = scope(&fixture["scope"]); + for row in fixture["vectors"].as_array().unwrap() { + let nodes = row["records"] + .as_array() + .unwrap() + .iter() + .map(|name| { + let record = &decoded[name.as_str().unwrap()]; + CausalRecord::new(record.record_id(), record.content()) + }) + .collect::<Vec<_>>(); + let capture = CapturedCausalCoverage::capture( + scope, + &nodes, + &ids(&row["external"]), + &ids(&row["uninterpreted"]), + ) + .unwrap(); + assert_eq!( + readiness(capture.analysis().readiness()), + row["readiness"].as_str().unwrap() + ); + if row["checkpoint"].is_null() { + assert!(capture.checkpoint().is_none(), "{}", row["name"]); + } else { + let checkpoint = capture.checkpoint().unwrap(); + assert_eq!( + checkpoint.digest().to_string(), + row["checkpoint"]["digest"].as_str().unwrap(), + "{}", + row["name"] + ); + assert_eq!( + checkpoint.sequence().get(), + row["checkpoint"]["sequence"].as_u64().unwrap() + ); + assert_eq!(checkpoint.coverage(), Coverage::ScopeSatisfied); + assert!(checkpoint.missing().is_empty()); + } + assert_eq!( + format!("{capture:?}"), + "CapturedCausalCoverage(<local coverage claims>)" + ); + let analysis = capture.analysis().clone(); + let checkpoint = capture.checkpoint().cloned(); + let parts = capture.into_parts(); + assert_eq!(parts, (analysis, checkpoint)); + } + assert_eq!( + fixture["vectors"][0]["checkpoint"], + fixture["vectors"][1]["checkpoint"] + ); + assert_ne!( + fixture["vectors"][0]["checkpoint"], + fixture["vectors"][2]["checkpoint"] + ); +} + +#[test] +fn claimed_ids_scope_and_limits_are_checked_before_a_coverage_descriptor_is_available() { + let fixture = fixture(); + let decoded = records(&fixture); + let scope = scope(&fixture["scope"]); + let record = &decoded["request"]; + let fake = CausalRecord::new(RecordId::from_bytes([0; 32]), record.content()); + assert_eq!( + CapturedCausalCoverage::capture(scope, &[fake], &[], &[]).unwrap_err(), + RecordWireError::IdentityMismatch + ); + let correct = CausalRecord::new(record.record_id(), record.content()); + assert_eq!(correct.record_id(), record.record_id()); + assert_eq!(correct.content(), record.content()); + let different = CausalScope::new( + ThreadId::from_bytes([0x55; 32]), + scope.order_id(), + scope.buyer(), + scope.seller(), + ) + .unwrap(); + assert_eq!( + CapturedCausalCoverage::capture(different, &[correct], &[], &[]).unwrap_err(), + RecordWireError::InvalidInput + ); + assert_eq!( + CapturedCausalCoverage::capture(scope, &vec![correct; 1001], &[], &[]).unwrap_err(), + RecordWireError::LimitExceeded + ); + assert_eq!( + CapturedCausalCoverage::capture( + scope, + &[], + &vec![SourceId::from_bytes([0; 32]); 8001], + &[] + ) + .unwrap_err(), + RecordWireError::LimitExceeded + ); +} + +#[test] +fn scope_binding_remains_explicit_even_for_empty_claims_and_does_not_invent_a_request() { + let fixture = fixture(); + let scope = scope(&fixture["scope"]); + let first = CapturedCausalCoverage::capture(scope, &[], &[], &[]).unwrap(); + let different = CausalScope::new( + scope.thread_id(), + OrderId::from_bytes([0x55; 32]), + scope.buyer(), + scope.seller(), + ) + .unwrap(); + let second = CapturedCausalCoverage::capture(different, &[], &[], &[]).unwrap(); + assert_ne!( + first.checkpoint().unwrap().digest(), + second.checkpoint().unwrap().digest() + ); + assert_eq!(first.checkpoint().unwrap().sequence().get(), 0); + assert!(first.analysis().buyer_head().is_none()); + assert!(first.analysis().seller_head().is_none()); +} + +#[test] +fn initial_request_claims_require_live_exact_sources_and_refuse_observed_withdrawal_or_decline() { + let fixture = fixture(); + let decoded = records(&fixture); + let scope = scope(&fixture["scope"]); + let request = decoded["request"].record_id(); + let base = fixture["vectors"][0].clone(); + let external = ids(&base["external"]); + let nodes = |names: &[&str]| { + names + .iter() + .map(|name| { + let record = &decoded[*name]; + CausalRecord::new(record.record_id(), record.content()) + }) + .collect::<Vec<_>>() + }; + let base_nodes = nodes(&["quote", "request"]); + let claim = prepare_initial_request( + scope, + request, + &base_nodes, + &external, + &[], + UnixSeconds::new(150).unwrap(), + ) + .unwrap(); + assert_eq!(claim.request(), request); + assert_eq!(claim.quote(), Some(decoded["quote"].record_id())); + assert_eq!(claim.expires_at().get(), 240); + let CommercePayload::Request(original) = decoded["request"].content().payload() else { + panic!() + }; + assert_eq!(claim.terms(), original.terms()); + assert_eq!(format!("{claim:?}"), "InitialRequestClaim(<private data>)"); + for (names, at, expected) in [ + (vec!["quote", "request"], 240, RequestClaimError::Expired), + (vec!["quote", "request"], 100, RequestClaimError::ClockAhead), + ( + vec!["quote", "request", "withdrawal"], + 150, + RequestClaimError::Withdrawn, + ), + ( + vec!["quote", "request", "decline"], + 150, + RequestClaimError::Declined, + ), + ( + vec!["quote", "request", "withdrawal", "buyer_fork"], + 150, + RequestClaimError::Conflicted, + ), + (vec!["request"], 150, RequestClaimError::MissingHistory), + ] { + assert_eq!( + prepare_initial_request( + scope, + request, + &nodes(&names), + &external, + &[], + UnixSeconds::new(at).unwrap() + ) + .unwrap_err(), + expected + ); + } + assert_eq!( + prepare_initial_request( + scope, + decoded["quote"].record_id(), + &base_nodes, + &external, + &[], + UnixSeconds::new(150).unwrap() + ) + .unwrap_err(), + RequestClaimError::WrongRequest + ); + let unknown = ids(&fixture["vectors"][7]["uninterpreted"]); + assert_eq!( + prepare_initial_request( + scope, + request, + &base_nodes, + &external, + &unknown, + UnixSeconds::new(150).unwrap() + ) + .unwrap_err(), + RequestClaimError::Uninterpreted + ); +} diff --git a/crates/protocol/tests/fixtures/commerce_coverage.v1.json b/crates/protocol/tests/fixtures/commerce_coverage.v1.json @@ -0,0 +1,224 @@ +{ + "schema_version": 1, + "transcript": "radroots.commerce.coverage.v1: NUL domain separator, scope thread/order/buyer/seller each32bytes, then known/required available external/uninterpreted sets eachu64BE count followed by sorted unique32byte identities", + "producer_sha256": "6cc668cc6d8189116fe0e1778d41937ef5d44e76096750771c3a09491af4a76f", + "source_path": "crates/storage_sqlite/tests/fixtures/stock_history.v1.json", + "source_sha256": "3aeefb11a077105d7a844b53e771922e6e555e118a361f22ce9d4b1877a325db", + "scope": { + "thread": "7171717171717171717171717171717171717171717171717171717171717171", + "order": "7272727272727272727272727272727272727272727272727272727272727272", + "buyer": "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5", + "seller": "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9" + }, + "records": { + "quote": { + "id": "ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a", + "wire": "{\"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🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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}" + }, + "request": { + "id": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4", + "wire": "{\"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🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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}" + }, + "request_rewrapped": { + "id": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4", + "wire": "{\"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🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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}" + }, + "withdrawal": { + "id": "113eab1ef364f4798df9d434c9d0d45c62179121025b26810b2b3025392d9bd9", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"author_sequence\":\"2\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\"],\"payload\":{\"authorization\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"reason\":\"Withdraw exact request\"},\"profile\":\"radroots.commerce\",\"record_id\":\"113eab1ef364f4798df9d434c9d0d45c62179121025b26810b2b3025392d9bd9\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"withdrawal_requested\",\"version\":1}" + }, + "buyer_fork": { + "id": "628f182a308bda2eb6f3875563ea56aec82dae4e491cee387f56af573b7893e2", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"author_sequence\":\"2\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\"],\"payload\":{\"authorization\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"reason\":\"Conflicting same-sequence statement\"},\"profile\":\"radroots.commerce\",\"record_id\":\"628f182a308bda2eb6f3875563ea56aec82dae4e491cee387f56af573b7893e2\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"withdrawal_requested\",\"version\":1}" + }, + "decline": { + "id": "d58afb1c571a5fba2b19caa48ded5b3f0b24b3b67464d7088baf55780522d813", + "wire": "{\"author\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\"],\"payload\":{\"reason\":\"Seller decline\",\"request\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\"},\"profile\":\"radroots.commerce\",\"record_id\":\"d58afb1c571a5fba2b19caa48ded5b3f0b24b3b67464d7088baf55780522d813\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"decline\",\"version\":1}" + }, + "missing_predecessor": { + "id": "0d017f9ab4336e81e90e054d5b4c9fd7c29b12422bae1df703cff095f8bc2770", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":\"abababababababababababababababababababababababababababababababab\",\"author_sequence\":\"3\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"abababababababababababababababababababababababababababababababab\"],\"payload\":{\"authorization\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"reason\":\"Missing predecessor\"},\"profile\":\"radroots.commerce\",\"record_id\":\"0d017f9ab4336e81e90e054d5b4c9fd7c29b12422bae1df703cff095f8bc2770\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"withdrawal_requested\",\"version\":1}" + }, + "wrong_predecessor": { + "id": "1a273f2d69cc0e5b8f449682e9b33c399f5d7d69bad21eb5a10d71686db51511", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\",\"author_sequence\":\"2\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\"],\"payload\":{\"authorization\":\"93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4\",\"reason\":\"Wrong predecessor author/scope\"},\"profile\":\"radroots.commerce\",\"record_id\":\"1a273f2d69cc0e5b8f449682e9b33c399f5d7d69bad21eb5a10d71686db51511\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"withdrawal_requested\",\"version\":1}" + }, + "unrelated": { + "id": "44b6ff2b1040a1bec19144ffea987f74922fdf72647e8c2b9910cbb59fc30829", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[],\"payload\":{\"code\":\"other\",\"description\":\"Independent unrelated scope\",\"lines\":[],\"source_records\":[]},\"profile\":\"radroots.commerce\",\"record_id\":\"44b6ff2b1040a1bec19144ffea987f74922fdf72647e8c2b9910cbb59fc30829\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7373737373737373737373737373737373737373737373737373737373737373\",\"type\":\"issue\",\"version\":1}" + }, + "request_no_quote": { + "id": "e539f4a846948aea057cdc3cf0df804232e7a519dcfef808bd049c13e382cd27", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\"],\"payload\":{\"expires_at\":\"240\",\"quote\":null,\"terms\":{\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"cancellation\":\"mutual_residual_v1\",\"fulfillment\":[{\"id\":\"0404040404040404040404040404040404040404040404040404040404040404\",\"terms\":{\"address\":\"Private pickup\\n🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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\":\"e539f4a846948aea057cdc3cf0df804232e7a519dcfef808bd049c13e382cd27\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + }, + "request_wrong_snapshot": { + "id": "da2fb66f0becfdc75ccea1b2e88e2b785e60f8d8701d45d18a976ac645c65b91", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\"],\"payload\":{\"expires_at\":\"240\",\"quote\":null,\"terms\":{\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"cancellation\":\"mutual_residual_v1\",\"fulfillment\":[{\"id\":\"0404040404040404040404040404040404040404040404040404040404040404\",\"terms\":{\"address\":\"Private pickup\\n🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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\":\"Changed copied option snapshot\",\"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 🥕\",\"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\":\"da2fb66f0becfdc75ccea1b2e88e2b785e60f8d8701d45d18a976ac645c65b91\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + }, + "request_wrong_quote_terms": { + "id": "40c30c113b944704d5c103ccffd4814c285c78c48faf8f6d238efb317b55e63a", + "wire": "{\"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🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬 Changed exact quote terms.\",\"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 🥕\",\"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\":\"40c30c113b944704d5c103ccffd4814c285c78c48faf8f6d238efb317b55e63a\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + }, + "request_early_expiry": { + "id": "780822705129bbb3f9ea2ce9e084907a89f7aaf7aa142c0130cfdb5cc8ed9953", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\",\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\"],\"payload\":{\"expires_at\":\"151\",\"quote\":\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\",\"terms\":{\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"cancellation\":\"mutual_residual_v1\",\"fulfillment\":[{\"id\":\"0404040404040404040404040404040404040404040404040404040404040404\",\"terms\":{\"address\":\"Private pickup\\n🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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\":\"780822705129bbb3f9ea2ce9e084907a89f7aaf7aa142c0130cfdb5cc8ed9953\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + }, + "request_other_order": { + "id": "ec41ba6c08862fcd71517c1a54bc69a58fa8ab94c34ed14778969855c1e645df", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7474747474747474747474747474747474747474747474747474747474747474\",\"parents\":[\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\"],\"payload\":{\"expires_at\":\"240\",\"quote\":null,\"terms\":{\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"cancellation\":\"mutual_residual_v1\",\"fulfillment\":[{\"id\":\"0404040404040404040404040404040404040404040404040404040404040404\",\"terms\":{\"address\":\"Private pickup\\n🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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\":\"ec41ba6c08862fcd71517c1a54bc69a58fa8ab94c34ed14778969855c1e645df\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + }, + "request_future_promise": { + "id": "52b48cb02297f4b5d4a6440ec3d07bae7297943f0c8bcefe829068a65e734ec7", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\"],\"payload\":{\"expires_at\":\"240\",\"quote\":null,\"terms\":{\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"cancellation\":\"mutual_residual_v1\",\"fulfillment\":[{\"id\":\"0404040404040404040404040404040404040404040404040404040404040404\",\"terms\":{\"address\":\"Private pickup\\n🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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 🥕\",\"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\":{\"expected_window\":{\"end\":\"400\",\"start\":\"300\",\"timezone\":\"Etc/UTC\"},\"risk_disclosure\":\"Weather and future supply may change.\",\"type\":\"future_promise\"}}},\"profile\":\"radroots.commerce\",\"record_id\":\"52b48cb02297f4b5d4a6440ec3d07bae7297943f0c8bcefe829068a65e734ec7\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + }, + "request_variable_weight": { + "id": "c9f55ea4fc1c4619ddbdd6c447989c809167555d55c6abd495a6a6beb82e977d", + "wire": "{\"author\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"author_previous\":null,\"author_sequence\":\"1\",\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":\"101\",\"order_id\":\"7272727272727272727272727272727272727272727272727272727272727272\",\"parents\":[\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\"],\"payload\":{\"expires_at\":\"240\",\"quote\":null,\"terms\":{\"buyer\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"cancellation\":\"mutual_residual_v1\",\"fulfillment\":[{\"id\":\"0404040404040404040404040404040404040404040404040404040404040404\",\"terms\":{\"address\":\"Private pickup\\n🥬\",\"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 \\\"\\\\/ Å Å 
 
 🥬\",\"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\":\"300\"},\"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\",\"maximum\":\"2\",\"maximum_total\":{\"currency\":\"CAD\",\"exponent\":2,\"minor\":\"300\"},\"measurement_unit\":\"kg\",\"minimum\":\"1\",\"rate\":{\"currency\":\"CAD\",\"exponent\":2,\"minor\":\"150\"},\"type\":\"variable_weight\"},\"product\":{\"description\":\"Independent public conformance fixture\",\"name\":\"Carrots 🥕\",\"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\":\"325\"},\"rounding\":\"half_even_net_line_v1\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"supply\":{\"type\":\"stock_backed\"}}},\"profile\":\"radroots.commerce\",\"record_id\":\"c9f55ea4fc1c4619ddbdd6c447989c809167555d55c6abd495a6a6beb82e977d\",\"seller\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"thread_id\":\"7171717171717171717171717171717171717171717171717171717171717171\",\"type\":\"request\",\"version\":1}" + } + }, + "vectors": [ + { + "name": "complete", + "records": [ + "quote", + "request" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0" + ], + "uninterpreted": [], + "readiness": "complete", + "checkpoint": { + "digest": "c5abd72c6e5d13a6ae9341ea73c8a06704a008f21c9a9eada1f1026eee95214f", + "sequence": 4 + } + }, + { + "name": "duplicates_and_unrelated_external", + "records": [ + "request", + "quote", + "request" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0", + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0", + "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" + ], + "uninterpreted": [], + "readiness": "complete", + "checkpoint": { + "digest": "c5abd72c6e5d13a6ae9341ea73c8a06704a008f21c9a9eada1f1026eee95214f", + "sequence": 4 + } + }, + { + "name": "withdrawal_is_relevant_evidence", + "records": [ + "quote", + "request", + "withdrawal" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0" + ], + "uninterpreted": [], + "readiness": "complete", + "checkpoint": { + "digest": "c0e0d85945990997cefa85e0bfe5621e74f0fab8a85658879219a12ab6cf06f2", + "sequence": 5 + } + }, + { + "name": "seller_order_head_is_relevant", + "records": [ + "quote", + "request", + "decline" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0" + ], + "uninterpreted": [], + "readiness": "complete", + "checkpoint": { + "digest": "540cf4c1ffdcb9a807efb1811e9722faa0f9f93cb7026c3ad636190326d26869", + "sequence": 5 + } + }, + { + "name": "missing_chat", + "records": [ + "quote", + "request" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b" + ], + "uninterpreted": [], + "readiness": "missing_history", + "checkpoint": null + }, + { + "name": "missing_quote", + "records": [ + "request" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0" + ], + "uninterpreted": [], + "readiness": "missing_history", + "checkpoint": null + }, + { + "name": "author_fork", + "records": [ + "quote", + "request", + "withdrawal", + "buyer_fork" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0" + ], + "uninterpreted": [], + "readiness": "conflicted", + "checkpoint": null + }, + { + "name": "uninterpreted", + "records": [ + "quote", + "request" + ], + "external": [ + "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0" + ], + "uninterpreted": [ + "152b30643b4a90996d3c0817b9cd0ed31cb1c3ee2b8cd59a040414b285c6049a" + ], + "readiness": "uninterpreted", + "checkpoint": null + }, + { + "name": "empty_is_data_only", + "records": [], + "external": [], + "uninterpreted": [], + "readiness": "complete", + "checkpoint": { + "digest": "21fd09c167e65983cbb898dd064ebefa59ae6081aac7de72594bc957a0c81388", + "sequence": 0 + } + } + ] +} diff --git a/crates/storage_sqlite/src/workspace/crypto.rs b/crates/storage_sqlite/src/workspace/crypto.rs @@ -709,7 +709,7 @@ fn stock_root_context( input: &super::AttachmentInput, version: i64, ) -> Result<EnvelopeContext, WorkspaceError> { - if matches!(version, 4..=8) { + if matches!(version, 4..=9) { use sha2::{Digest, Sha256}; let namespace = radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment( @@ -730,8 +730,10 @@ fn stock_root_context( b"radroots.seller_stock.authority_context.v6\0" } else if version == 7 { b"radroots.seller_stock.authority_context.v7\0" - } else { + } else if version == 8 { b"radroots.seller_stock.authority_context.v8\0" + } else { + b"radroots.seller_stock.authority_context.v9\0" }); hash.update(wire.as_slice()); let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into()); @@ -748,8 +750,10 @@ fn stock_root_context( "radroots.seller_stock.authority.v6" } else if version == 7 { "radroots.seller_stock.authority.v7" - } else { + } else if version == 8 { "radroots.seller_stock.authority.v8" + } else { + "radroots.seller_stock.authority.v9" }) .map_err(|_| WorkspaceError::InvalidInput)?, )); @@ -798,6 +802,14 @@ fn stock_record_context( "radroots.seller_stock.public_source_part", "radroots.seller_stock.public_source_part.v1", ), + "order" => ( + "radroots.seller_stock.order", + "radroots.seller_stock.order.v1", + ), + "acceptance_movement" => ( + "radroots.seller_stock.acceptance_movement", + "radroots.seller_stock.acceptance_movement.v1", + ), "operation_part" => ( "radroots.seller_stock.operation_part", "radroots.seller_stock.operation_part.v1", @@ -851,12 +863,12 @@ fn stock_record_context_for_catalog( ) -> Result<EnvelopeContext, WorkspaceError> { let original = stock_record_context(input, kind, id)?; let schema = match (catalog, kind) { - (2, _) | (3..=8, "pool") => return Ok(original), + (2, _) | (3..=9, "pool") => return Ok(original), (3, "operation") => "radroots.seller_stock.operation.v2", (4, "operation") => "radroots.seller_stock.operation.v3", (5 | 6, "operation") => "radroots.seller_stock.operation.v4", - (7 | 8, "operation") => "radroots.seller_stock.operation.v5", - (3..=8, "movement") => "radroots.seller_stock.movement.v2", + (7..=9, "operation") => "radroots.seller_stock.operation.v5", + (3..=9, "movement") => "radroots.seller_stock.movement.v2", _ => return Err(WorkspaceError::RecoveryRequired), }; Ok(EnvelopeContext::new( diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs @@ -23,10 +23,11 @@ mod schema; mod snapshot; mod stock; pub use stock::{ - SellerStockConfig, StockAuthorityReceipt, StockConsentCapture, StockConsentMode, - StockConsentOutcome, StockConsentReceipt, StockEnrollment, StockGrantEnrollment, - StockGrantOutcome, StockGrantReceipt, StockHistorySnapshot, StockListingCapture, - StockListingOutcome, StockListingReceipt, StockListingSnapshot, StockSourceCapture, + SellerStockConfig, StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, + StockAuthorityReceipt, StockConsentCapture, StockConsentMode, StockConsentOutcome, + StockConsentReceipt, StockEnrollment, StockGrantEnrollment, StockGrantOutcome, + StockGrantReceipt, StockHistorySnapshot, StockListingCapture, StockListingOutcome, + StockListingReceipt, StockListingSnapshot, StockRequestSnapshot, StockSourceCapture, StockSourceOutcome, StockSourceProfile, StockSourceReceipt, StockSourceSnapshot, }; mod worker; diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs @@ -13,6 +13,9 @@ pub use consent::{ StockConsentCapture, StockConsentMode, StockConsentOutcome, StockConsentReceipt, }; pub(in crate::workspace) mod grants; +pub use inventory::acceptance::{ + StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, +}; mod ledger; pub(in crate::workspace) mod public_source; pub use public_source::{ @@ -23,8 +26,8 @@ use grants::StockRecord; pub use grants::{StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt}; use serde::{Deserialize, Serialize}; pub use source::{ - StockHistorySnapshot, StockSourceCapture, StockSourceOutcome, StockSourceProfile, - StockSourceReceipt, StockSourceSnapshot, + StockHistorySnapshot, StockRequestSnapshot, StockSourceCapture, StockSourceOutcome, + StockSourceProfile, StockSourceReceipt, StockSourceSnapshot, }; use sqlx::{Connection, SqliteConnection}; use std::{ @@ -418,17 +421,17 @@ struct AuthorityV8 { } impl Authority { fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> { - if self.catalog != 8 && self.public_sources.is_some() { + if !matches!(self.catalog, 8 | 9) && self.public_sources.is_some() { return Err(WorkspaceError::RecoveryRequired); } - if self.catalog == 8 { + if matches!(self.catalog, 8 | 9) { let public_sources = self .public_sources .ok_or(WorkspaceError::RecoveryRequired)?; public_sources.validate()?; let bytes = zeroize::Zeroizing::new( serde_json::to_vec(&AuthorityV8 { - version: 8, + version: self.catalog as u8, namespace: SellerAuthoritySelection::from_attachment(&self.input), administrator: self.input.grant_id(), transaction: self.transaction, @@ -673,10 +676,10 @@ impl Authority { public_sources: None, } } - 8 => { + 8 | 9 => { let value: AuthorityV8 = closed_record(bytes)?; value.public_sources.validate()?; - if value.version != 8 + if i64::from(value.version) != catalog || value.authorization.generation() != value.revocation || (value.inventory.revision.get() == 0) != value.inventory.head.is_none() || value.inventory.orders.get() > value.inventory.revision.get() @@ -803,7 +806,7 @@ pub(super) async fn initialize( .await .map_err(|_| WorkspaceError::StorageFailure)?; } - sqlx::query("PRAGMA user_version=8") + sqlx::query("PRAGMA user_version=9") .execute(&mut *tx) .await .map_err(|_| WorkspaceError::StorageFailure)?; diff --git a/crates/storage_sqlite/src/workspace/stock/consent.rs b/crates/storage_sqlite/src/workspace/stock/consent.rs @@ -266,9 +266,10 @@ pub(super) struct Retained { pub subject: GrantId, pub expires: UnixSeconds, pub authorization: StockAuthorizationRef, + pub subject_digest: [u8; 32], } impl Retained { - fn identity(&self) -> inventory::checkpoint::EntryIdentity { + pub(super) fn identity(&self) -> inventory::checkpoint::EntryIdentity { inventory::checkpoint::EntryIdentity { operation: self.frame.header.operation, revision: self.frame.header.revision, @@ -383,6 +384,7 @@ pub(super) async fn read( let subject = body.subject; let expires = body.expires; let authorization = body.authorization; + let subject_digest = body.subject_digest; Ok(Some(Retained { frame, command, @@ -391,10 +393,11 @@ pub(super) async fn read( subject, expires, authorization, + subject_digest, })) } -async fn natural( +pub(super) async fn natural( connection: &mut SqliteConnection, participant: radroots_domain::PublicKey, operation: OperationId, @@ -419,7 +422,7 @@ pub(in crate::workspace) async fn issue( proof: AttachmentProof, ) -> Result<StockConsentOutcome, OperationError> { let access = turn.access(&binding, minimum, &proof).await?; - if !matches!(access.authority.catalog, 7 | 8) { + if !matches!(access.authority.catalog, 7..=9) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() @@ -680,7 +683,7 @@ pub(in crate::workspace) async fn query( proof: AttachmentProof, ) -> Result<Option<StockConsentReceipt>, OperationError> { let access = turn.access(&binding, minimum, &proof).await?; - if !matches!(access.authority.catalog, 7 | 8) { + if !matches!(access.authority.catalog, 7..=9) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() && access.current.input().grant_id() != subject { diff --git a/crates/storage_sqlite/src/workspace/stock/consent/test_provider.rs b/crates/storage_sqlite/src/workspace/stock/consent/test_provider.rs @@ -74,7 +74,7 @@ impl KeyWrapping for Provider { fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> { Box::pin(async move { let result = self.inner.wrap(request).await; - if request.context().payload_schema().as_str() == "radroots.seller_stock.authority.v8" { + if request.context().payload_schema().as_str() == "radroots.seller_stock.authority.v9" { self.gate.pause(); } result diff --git a/crates/storage_sqlite/src/workspace/stock/grants.rs b/crates/storage_sqlite/src/workspace/stock/grants.rs @@ -324,7 +324,7 @@ pub(in crate::workspace) async fn change( } let (mut authority, record, old_root, old_grant) = super::read(turn.connection, change.caller.input(), turn.crypto).await?; - if !(4..=8).contains(&authority.catalog) { + if !(4..=9).contains(&authority.catalog) { return Err(WorkspaceError::Unauthorized); } let catalog = authority.catalog; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory.rs b/crates/storage_sqlite/src/workspace/stock/inventory.rs @@ -1,4 +1,5 @@ //! Owner-private inventory effects on the existing connection owner. +pub(in crate::workspace) mod acceptance; pub(super) mod checkpoint; mod codec; mod mapping; @@ -447,7 +448,7 @@ impl Turn<'_> { access.authority.authorization, mapping.as_ref().map(|value| value.effect), )?; - let framed = if matches!(catalog, 7 | 8) { + let framed = if matches!(catalog, 7..=9) { Some( super::ledger::prepare( self.crypto, @@ -861,7 +862,7 @@ pub(super) async fn read_operation( .fetch_one(&mut *connection) .await .map_err(|_| OperationError::RecoveryRequired)?; - let (frame, request, decoded) = if matches!(catalog, 7 | 8) { + let (frame, request, decoded) = if matches!(catalog, 7..=9) { let retained = super::ledger::read(connection, input, crypto, operation) .await? .ok_or(OperationError::RecoveryRequired)?; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs b/crates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs @@ -0,0 +1,807 @@ +//! Native T0: retained command, complete preparatory holds and one order fence. +//! This boundary performs no signing, installation, delivery or physical claim. +use super::super::{consent, ledger, source}; +use super::*; +use radroots_domain::{CheckpointRef, OrderId, RecordId, TermsDigest}; +use radroots_protocol::command::CapturedOrderAcceptance; +use radroots_storage::inventory::InventoryCheckpointRef; +use radroots_storage::workspace::seller_stock::{ + StockListingCheckpointRef, StockSourceCheckpointRef, +}; +use std::collections::{BTreeMap, BTreeSet}; +pub(in crate::workspace::stock) mod codec; +mod plan; + +/// Captured input data. Execution still requires current authenticated consent. +pub struct StockAcceptanceRequest { + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + sources: StockSourceCheckpointRef, + listings: StockListingCheckpointRef, + command: CapturedOrderAcceptance, +} +impl StockAcceptanceRequest { + pub fn capture( + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + sources: StockSourceCheckpointRef, + listings: StockListingCheckpointRef, + command: &CapturedOrderAcceptance, + ) -> Result<Self, OperationError> { + let command = CapturedOrderAcceptance::parse(command.protected_wire()) + .map_err(|_| OperationError::InvalidCommand)?; + Ok(Self { + binding, + minimum, + sources, + listings, + command, + }) + } + pub(in crate::workspace) fn attempt(&self) -> CommitAttempt { + CommitAttempt::new( + self.binding.input().workspace_id(), + self.command.context().operation_id(), + self.command.digest(), + None, + ) + } +} +impl std::fmt::Debug for StockAcceptanceRequest { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("StockAcceptanceRequest(<private command>)") + } +} +/// Confirmed T0 preparation, distinct from a signed or installed agreement. +#[derive(Clone)] +pub struct StockAcceptanceReceipt { + attempt: CommitAttempt, + order: OrderId, + request: RecordId, + terms: TermsDigest, + checkpoint: InventoryCheckpointRef, + pools: Vec<PoolSnapshot>, + allocations: usize, + observed: UnixSeconds, + issue_before: UnixSeconds, +} +impl StockAcceptanceReceipt { + pub const fn attempt(&self) -> CommitAttempt { + self.attempt + } + pub const fn order_id(&self) -> OrderId { + self.order + } + pub const fn request(&self) -> RecordId { + self.request + } + pub const fn terms_digest(&self) -> TermsDigest { + self.terms + } + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } + /// Exact after-images of actual preparatory holds, sorted by pool identity. + pub fn held_pools(&self) -> &[PoolSnapshot] { + &self.pools + } + pub const fn allocation_count(&self) -> usize { + self.allocations + } + pub const fn prepared_at(&self) -> UnixSeconds { + self.observed + } + pub const fn first_issue_deadline(&self) -> UnixSeconds { + self.issue_before + } +} +impl std::fmt::Debug for StockAcceptanceReceipt { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("StockAcceptanceReceipt(<private preparation>)") + } +} +#[derive(Debug)] +pub enum StockAcceptanceOutcome { + Prepared(Box<StockAcceptanceReceipt>), + Unknown(CommitAttempt), +} + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Body<'a> { + version: u8, + #[serde(borrow)] + command: &'a RawValue, + #[serde(borrow)] + terms: &'a RawValue, + #[serde(borrow)] + original_request: &'a RawValue, + #[serde(borrow, deserialize_with = "super::super::required_nullable")] + original_quote: Option<&'a RawValue>, + #[serde(deserialize_with = "super::super::required_nullable")] + seller_author_head: Option<RecordId>, + seller_author_sequence: Sequence, + minimum_revision: Sequence, + #[serde(deserialize_with = "super::super::required_nullable")] + minimum_head: Option<CheckpointDigest>, + authorization: StockAuthorizationRef, + source_minimum: Progress, + listing_minimum: Progress, + coverage: CheckpointRef, + buyer_head: Option<RecordId>, + observed_at: UnixSeconds, + expires: UnixSeconds, + issue_before: UnixSeconds, + consent: OperationId, + mappings: Vec<radroots_domain::stock::OptionPoolMapping>, + pools: Vec<PoolSnapshot>, + allocations: Vec<plan::Allocation>, + effects: Vec<plan::Effect>, + movements: Vec<[u8; 32]>, +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Progress { + authority: radroots_domain::AuthorityRef, + revision: Sequence, + #[serde(deserialize_with = "super::super::required_nullable")] + head: Option<CheckpointDigest>, + authorization: StockAuthorizationRef, +} +impl Progress { + fn source(value: StockSourceCheckpointRef) -> Result<Self, OperationError> { + Ok(Self { + authority: value.authority(), + revision: value.revision(), + head: value.head(), + authorization: value + .authorization() + .ok_or(OperationError::RecoveryRequired)?, + }) + } + fn listing(value: StockListingCheckpointRef) -> Result<Self, OperationError> { + Ok(Self { + authority: value.authority(), + revision: value.revision(), + head: value.head(), + authorization: value + .authorization() + .ok_or(OperationError::RecoveryRequired)?, + }) + } +} +#[derive(Serialize, Deserialize, Eq, PartialEq)] +#[serde(deny_unknown_fields)] +struct Fence { + version: u8, + order: OrderId, + operation: OperationId, + digest: CommandDigest, + transaction: TransactionId, + revision: Sequence, + request: RecordId, + terms: TermsDigest, +} +fn fence( + header: &ledger::Header, + command: &CapturedOrderAcceptance, +) -> Result<Fence, OperationError> { + Ok(Fence { + version: 1, + order: header.order.ok_or(OperationError::RecoveryRequired)?, + operation: header.operation, + digest: header.digest, + transaction: header.transaction, + revision: Sequence::new(1).map_err(|_| OperationError::RecoveryRequired)?, + request: command.input().request(), + terms: command.input().terms_digest(), + }) +} +fn bytes(value: &impl Serialize) -> Result<zeroize::Zeroizing<Vec<u8>>, OperationError> { + let bytes = zeroize::Zeroizing::new( + serde_json::to_vec(value).map_err(|_| OperationError::StorageFailure)?, + ); + if bytes.is_empty() || bytes.len() > ledger::BODY_MAX_BYTES { + return Err(WorkspaceError::Capacity.into()); + } + Ok(bytes) +} +fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { + let mut h = Sha256::new(); + h.update(b"radroots.seller_stock.acceptance_chain.v1\0"); + h.update(header.namespace.workspace_id().as_bytes()); + h.update(header.namespace.authority().executor_id().as_bytes()); + h.update( + header + .namespace + .authority() + .generation() + .get() + .to_be_bytes(), + ); + h.update(header.namespace.route_digest().as_bytes()); + h.update([u8::from(header.previous.is_some())]); + h.update( + header + .previous + .map(|value| *value.as_bytes()) + .unwrap_or([0; 32]), + ); + h.update(header.revision.get().to_be_bytes()); + h.update(header.actor.participant().as_bytes()); + h.update( + header + .actor + .grant_id() + .map(|value| *value.as_bytes()) + .unwrap_or([0; 32]), + ); + h.update(header.operation.as_bytes()); + h.update(header.digest.as_bytes()); + h.update(header.transaction.as_bytes()); + h.update(Sha256::digest(body)); + CheckpointDigest::from_bytes(h.finalize().into()) +} +fn check_consent( + access: &Access, + scope: &consent::Retained, + command: &CapturedOrderAcceptance, + fresh: bool, + at: UnixSeconds, +) -> Result<(), OperationError> { + if scope.command.digest() != command.digest() { + return Err(OperationError::IdempotencyConflict); + } + if scope.subject != access.current.input().grant_id() + || scope.authorization + != access + .authority + .authorization + .ok_or(OperationError::RecoveryRequired)? + || scope.subject_digest != <[u8; 32]>::from(Sha256::digest(&access.grant)) + || (fresh && scope.mode != consent::StockConsentMode::ExecuteAndRecover) + { + return Err(OperationError::Unauthorized); + } + if at >= scope.expires { + return Err(OperationError::DeadlineExceeded); + } + if fresh { + if command.context().actor() != access.current.actor() { + return Err(OperationError::Unauthorized); + } + if at >= command.context().not_after() + || command + .context() + .approval() + .is_none_or(|approval| at >= approval.expires_at()) + { + return Err(OperationError::DeadlineExceeded); + } + } + Ok(()) +} +async fn current_consent( + turn: &mut Turn<'_>, + access: &Access, + command: &CapturedOrderAcceptance, +) -> Result<(consent::Retained, MinimumProof), OperationError> { + let operation = consent::natural( + turn.connection, + turn.selected.participant(), + command.context().operation_id(), + access.current.input().grant_id(), + ) + .await?; + let retained = if let Some(operation) = operation { + consent::read( + turn.connection, + turn.selected, + turn.crypto, + access.authority.input.grant_id(), + operation, + ) + .await? + } else { + None + }; + let proof = checkpoint::authenticate_identity( + turn.connection, + turn.selected, + turn.crypto, + &access.current, + &access.authority, + checkpoint::IdentityTarget::Consent { + operation: command.context().operation_id(), + subject: access.current.input().grant_id(), + expected: retained.as_ref().map(consent::Retained::identity), + }, + ) + .await?; + Ok((retained.ok_or(OperationError::Unauthorized)?, proof)) +} + +/// Preserves one original operation across lost observers and store reopen. +pub(in crate::workspace) async fn admit( + turn: &mut Turn<'_>, + request: StockAcceptanceRequest, + proof: AttachmentProof, +) -> Result<StockAcceptanceOutcome, OperationError> { + let access = turn + .access(&request.binding, request.minimum, &proof) + .await?; + if access.authority.catalog != 9 { + return Err(OperationError::UnsupportedOperation); + } + let command = &request.command; + let operation = command.context().operation_id(); + let original = codec::read(turn.connection, turn.selected, turn.crypto, operation).await?; + let identity = checkpoint::authenticate_identity( + turn.connection, + turn.selected, + turn.crypto, + &access.current, + &access.authority, + checkpoint::IdentityTarget::Operation( + operation, + original.as_ref().map(|value| value.identity()), + ), + ) + .await?; + let (consent, consent_proof) = current_consent(turn, &access, command).await?; + check_consent( + &access, + &consent, + command, + original.is_none(), + access.current.observed_at(), + )?; + if let Some(original) = original { + if original.frame.header.digest != command.digest() { + return Err(OperationError::IdempotencyConflict); + } + for pool in &original.receipt.pools { + if !consent.resources.contains(pool.id()) { + return Err(OperationError::Unauthorized); + } + } + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<(), OperationError> = async { + identity.confirm(&mut tx).await?; + consent_proof.confirm(&mut tx).await?; + original.confirm(&mut tx).await?; + let current = access + .confirm(&mut tx, turn.namespace, turn.clock, &proof) + .await?; + check_consent(&access, &consent, command, false, current.observed_at())?; + Ok(()) + } + .await; + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + checked?; + return Ok(StockAcceptanceOutcome::Prepared(Box::new(original.receipt))); + } + // All fresh source/mapping/pool planning follows original identity recovery. + super::super::check_source_counts( + turn.connection, + access + .authority + .sources + .ok_or(OperationError::RecoveryRequired)?, + ) + .await?; + if request.sources.authorization() != access.authority.authorization { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + let source_minimum = source::checkpoint::authenticate( + turn.connection, + turn.selected, + turn.crypto, + access + .authority + .sources + .ok_or(OperationError::RecoveryRequired)?, + source::checkpoint::Target::Minimum(request.sources), + ) + .await?; + let admitted = source::request::prepare( + turn.connection, + turn.selected, + turn.crypto, + &access.authority, + command.input().request(), + request.listings, + access.current.observed_at(), + ) + .await?; + let expected = command + .context() + .expected() + .ok_or(OperationError::InvalidCommand)?; + if expected.order_id() != admitted.scope.order_id() + || expected.agreement().is_some() + || expected.seller_sequence().get() != 0 + || expected.buyer_head() != admitted.history.analysis.buyer_head() + || Some(expected.checkpoint()) != admitted.history.checkpoint.as_ref() + || command.input().terms_digest() != admitted.digest + || command.context().workspace_id() != turn.selected.workspace_id() + || command.context().authority() != turn.selected.authority() + || command.context().route_digest() != turn.selected.route_digest() + { + return Err(OperationError::StaleState); + } + let order_proof = checkpoint::authenticate_order_absence( + turn.connection, + turn.selected, + turn.crypto, + &access.current, + &access.authority, + expected.order_id(), + ) + .await?; + let mut mappings = Vec::new(); + let mut mapping_reads = Vec::new(); + let mut pool_ids = BTreeSet::new(); + if matches!( + admitted.terms()?.supply(), + radroots_domain::SupplyCommitment::StockBacked + ) { + for line in admitted.terms()?.lines() { + let key = radroots_domain::stock::OptionMappingKey::new( + line.source().coordinate(), + line.option_id(), + ); + let retained = mapping::read(turn.connection, turn.selected, turn.crypto, key).await?; + let witness = checkpoint::authenticate_mapping_projection( + turn.connection, + turn.selected, + turn.crypto, + &access.current, + &access.authority, + key, + retained.as_ref().map(|value| value.value), + ) + .await?; + let value = retained.as_ref().ok_or(OperationError::StaleState)?.value; + pool_ids.insert(value.pool_id()); + mappings.push(value); + mapping_reads.push(mapping::MappingRead { + key, + retained, + proof: witness, + }); + } + if let Some(explicit) = command.input().allocation().explicit_allocations() { + pool_ids.extend(explicit.iter().map(|value| value.pool_id())); + } + } + let mut pool_reads = BTreeMap::new(); + let mut pool_proofs = Vec::new(); + let mut before_pools = Vec::new(); + for id in pool_ids { + if !consent.resources.contains(id) { + return Err(OperationError::Unauthorized); + } + let retained = read_pool(turn.connection, turn.selected, turn.crypto, id).await?; + pool_proofs.push( + checkpoint::authenticate_projection( + turn.connection, + turn.selected, + turn.crypto, + &access.current, + &access.authority, + id, + retained.as_ref().map(|value| value.pool), + ) + .await?, + ); + let retained = retained.ok_or(OperationError::StaleState)?; + before_pools.push(retained.pool); + pool_reads.insert(id, retained); + } + let (allocations, effects) = + plan::resolve(admitted.terms()?, command, &mappings, &before_pools)?; + let before = access + .authority + .inventory + .ok_or(OperationError::RecoveryRequired)?; + let transaction = TransactionId::from_bytes(super::super::super::random()?); + let revision = Sequence::new( + before + .revision + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?; + let expires = admitted + .expires + .min(command.context().not_after()) + .min(consent.expires) + .min( + command + .context() + .approval() + .ok_or(OperationError::UnverifiedApproval)? + .expires_at(), + ) + .min(access.current.expires_at()); + let issue_before = UnixSeconds::new( + access + .current + .observed_at() + .get() + .checked_add(120) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)? + .min(expires); + let mut movements = Vec::new(); + for _ in &effects { + movements.push(super::super::super::random()?); + } + let terms = radroots_protocol::terms::EncodedTerms::capture(admitted.terms()?) + .map_err(|_| OperationError::InvalidEvidence)?; + let original_request = radroots_protocol::commerce::EncodedRecord::capture( + admitted + .history + .records + .get(&admitted.request) + .ok_or(OperationError::RecoveryRequired)? + .content(), + ) + .map_err(|_| OperationError::RecoveryRequired)?; + let original_quote = admitted + .quote + .map(|id| { + radroots_protocol::commerce::EncodedRecord::capture( + admitted + .history + .records + .get(&id) + .ok_or(OperationError::RecoveryRequired)? + .content(), + ) + .map_err(|_| OperationError::RecoveryRequired) + }) + .transpose()?; + let seller_author_head = admitted.history.analysis.seller_head(); + let seller_author_sequence = seller_author_head + .map(|id| { + admitted + .history + .records + .get(&id) + .map(|record| record.content().header().author_sequence()) + .ok_or(OperationError::RecoveryRequired) + }) + .transpose()? + .unwrap_or(Sequence::new(0).map_err(|_| OperationError::RecoveryRequired)?); + let body = Body { + version: 1, + command: serde_json::from_slice(command.protected_wire()) + .map_err(|_| OperationError::InvalidCommand)?, + terms: serde_json::from_slice(terms.protected_wire()) + .map_err(|_| OperationError::InvalidEvidence)?, + original_request: serde_json::from_slice(original_request.protected_wire()) + .map_err(|_| OperationError::RecoveryRequired)?, + original_quote: original_quote + .as_ref() + .map(|quote| { + serde_json::from_slice(quote.protected_wire()) + .map_err(|_| OperationError::RecoveryRequired) + }) + .transpose()?, + seller_author_head, + seller_author_sequence, + minimum_revision: request.minimum.revision(), + minimum_head: request.minimum.head(), + authorization: access + .authority + .authorization + .ok_or(OperationError::RecoveryRequired)?, + source_minimum: Progress::source(request.sources)?, + listing_minimum: Progress::listing(request.listings)?, + coverage: expected.checkpoint().clone(), + buyer_head: expected.buyer_head(), + observed_at: access.current.observed_at(), + expires, + issue_before, + consent: consent.frame.header.operation, + mappings, + pools: before_pools, + allocations, + effects, + movements, + }; + let raw = bytes(&body)?; + let mut header = ledger::Header { + version: 5, + family: ledger::Family::Acceptance, + namespace: SellerAuthoritySelection::from_attachment(turn.selected), + actor: command.context().actor(), + operation, + digest: command.digest(), + transaction, + revision, + previous: before.head, + head: CheckpointDigest::from_bytes([0; 32]), + pool: None, + order: Some(expected.order_id()), + related_operation: None, + subject_grant: None, + bytes: 0, + parts: 0, + body_digest: [0; 32], + }; + header.head = head(&header, &raw); + let framed = ledger::prepare( + turn.crypto, + turn.selected, + header_for_prepare(&header), + &raw, + ) + .await?; + let fence = fence(&header, command)?; + let order_cipher = turn + .crypto + .seal_stock_record( + turn.selected, + "order", + fence.order.as_bytes(), + &bytes(&fence)?, + ) + .await?; + let mut changed_pools = Vec::new(); + let mut changed_movements = Vec::new(); + for (effect, movement) in body.effects.iter().zip(&body.movements) { + let original = &pool_reads[&effect.before().id()]; + changed_pools.push( + turn.crypto + .seal_stock_record( + turn.selected, + "pool", + effect.after().id().as_bytes(), + &encode(&PoolWire { + version: 1, + label: original.view.label(), + pool: effect.after(), + })?, + ) + .await?, + ); + changed_movements.push( + turn.crypto + .seal_stock_record( + turn.selected, + "acceptance_movement", + movement, + &bytes(&codec::Hold { + version: 1, + operation, + digest: command.digest(), + order: fence.order, + effect: *effect, + })?, + ) + .await?, + ); + } + let mut next = access.authority.clone(); + next.inventory = Some(InventoryCheckpoint { + revision, + head: Some(header.head), + orders: Some( + Sequence::new( + before + .orders + .ok_or(OperationError::RecoveryRequired)? + .get() + .checked_add(1) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?, + ), + movements: Sequence::new( + before + .movements + .get() + .checked_add(body.effects.len() as u64) + .ok_or(WorkspaceError::Capacity)?, + ) + .map_err(|_| WorkspaceError::Capacity)?, + ..before + }); + let root = turn + .crypto + .seal_stock_root(turn.selected, 9, &next.encode()?) + .await?; + let receipt = codec::receipt(turn.selected, &header, &body, command)?; + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let changed: Result<(), OperationError> = async { + identity.confirm(&mut tx).await?; consent_proof.confirm(&mut tx).await?; source_minimum.confirm(&mut tx).await?; + order_proof.confirm(&mut tx).await?; admitted.confirm(&mut tx).await?; + super::super::check_source_counts(&mut tx, access.authority.sources.ok_or(OperationError::RecoveryRequired)?).await?; + for mapping in &mapping_reads { mapping.confirm(&mut tx).await?; } + for witness in &pool_proofs { witness.confirm(&mut tx).await?; } + for retained in pool_reads.values() { + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_pools WHERE pool_id=? AND revision=? AND protected=?").bind(retained.pool.id().as_bytes().as_slice()).bind(retained.pool.version().get() as i64).bind(&retained.protected).fetch_one(&mut *tx).await.map_err(|_| OperationError::RecoveryRequired)?; + if count != 1 { return Err(OperationError::RecoveryRequired); } + } + let current = access.confirm(&mut tx, turn.namespace, turn.clock, &proof).await?; + check_consent(&access, &consent, command, true, current.observed_at())?; admitted.validate_at(current.observed_at())?; + if current.observed_at() >= body.issue_before { return Err(OperationError::DeadlineExceeded); } + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_orders WHERE order_id=?").bind(fence.order.as_bytes().as_slice()).fetch_one(&mut *tx).await.map_err(|_| OperationError::StorageFailure)?; + if count != 0 { return Err(OperationError::StaleState); } + sqlx::query("INSERT INTO stock_operations(actor,grant_id,operation_id,command_digest,transaction_id,pool_id,revision,chain_head,protected,family,order_id,related_operation,subject_grant) VALUES(?,?,?,?,?,NULL,?,?,?,2,?,NULL,NULL)") + .bind(header.actor.participant().as_bytes().as_slice()).bind(access.current.input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(header.digest.as_bytes().as_slice()).bind(transaction.as_bytes().as_slice()).bind(revision.get() as i64).bind(header.head.as_bytes().as_slice()).bind(&framed.protected).bind(fence.order.as_bytes().as_slice()).execute(&mut *tx).await.map_err(|_| OperationError::StorageFailure)?; + framed.insert_parts(&mut tx, header.actor, operation).await?; + for (index, effect) in body.effects.iter().enumerate() { + let original = &pool_reads[&effect.before().id()]; + let updated = sqlx::query("UPDATE stock_pools SET revision=?,protected=? WHERE pool_id=? AND revision=? AND protected=?").bind(effect.after().version().get() as i64).bind(&changed_pools[index]).bind(effect.before().id().as_bytes().as_slice()).bind(effect.before().version().get() as i64).bind(&original.protected).execute(&mut *tx).await.map_err(|_| OperationError::StorageFailure)?; + if updated.rows_affected() != 1 { return Err(OperationError::StaleState); } + sqlx::query("INSERT INTO stock_movements(movement_id,actor,grant_id,operation_id,pool_id,protected) VALUES(?,?,?,?,?,?)").bind(body.movements[index].as_slice()).bind(header.actor.participant().as_bytes().as_slice()).bind(access.current.input().grant_id().as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(effect.before().id().as_bytes().as_slice()).bind(&changed_movements[index]).execute(&mut *tx).await.map_err(|_| OperationError::StorageFailure)?; + } + sqlx::query("INSERT INTO stock_orders(order_id,revision,protected) VALUES(?,?,?)").bind(fence.order.as_bytes().as_slice()).bind(fence.revision.get() as i64).bind(order_cipher).execute(&mut *tx).await.map_err(|_| OperationError::StorageFailure)?; + let updated = sqlx::query("UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?").bind(root).bind(&access.root).execute(&mut *tx).await.map_err(|_| OperationError::StorageFailure)?; + if updated.rows_affected() != 1 { return Err(OperationError::RecoveryRequired); } + turn.namespace.validate()?; Ok(()) + }.await; + let attempt = receipt.attempt; + if let Err(error) = changed { + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Ok(StockAcceptanceOutcome::Unknown(attempt)); + } + return Err(error); + } + if tx.commit().await.is_err() { + *turn.uncertain = true; + return Ok(StockAcceptanceOutcome::Unknown(attempt)); + } + Ok(StockAcceptanceOutcome::Prepared(Box::new(receipt))) +} +fn header_for_prepare(header: &ledger::Header) -> ledger::Header { + ledger::Header { + version: header.version, + family: header.family, + namespace: header.namespace.clone(), + actor: header.actor, + operation: header.operation, + digest: header.digest, + transaction: header.transaction, + revision: header.revision, + previous: header.previous, + head: header.head, + pool: header.pool, + order: header.order, + related_operation: header.related_operation, + subject_grant: header.subject_grant, + bytes: header.bytes, + parts: header.parts, + body_digest: header.body_digest, + } +} +impl NativeWorkspace { + /// Atomically prepares an original acceptance and its physical holds. This + /// never invokes a signer or installs a bilateral agreement. + pub async fn prepare_stock_acceptance( + &self, + request: StockAcceptanceRequest, + proof: &AttachmentProof, + ) -> Result<StockAcceptanceOutcome, OperationError> { + let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; + self.worker.prepare_stock_acceptance(request, proof).await + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/acceptance/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/acceptance/codec.rs @@ -0,0 +1,283 @@ +//! Exact original preparation validation, independent of fresh source readiness. +use super::*; + +#[derive(Serialize, Deserialize, Eq, PartialEq)] +#[serde(deny_unknown_fields)] +pub(super) struct Hold { + pub version: u8, + pub operation: OperationId, + pub digest: CommandDigest, + pub order: OrderId, + pub effect: plan::Effect, +} +pub(in crate::workspace::stock) struct Retained { + pub frame: ledger::Retained, + pub receipt: StockAcceptanceReceipt, + pub movements: Vec<ledger::MovementWitness>, + order_cipher: Vec<u8>, +} +impl Retained { + pub fn identity(&self) -> checkpoint::EntryIdentity { + checkpoint::EntryIdentity { + operation: self.frame.header.operation, + revision: self.frame.header.revision, + head: self.frame.header.head, + protected_digest: Sha256::digest(&self.frame.protected).into(), + } + } + pub async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> { + ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?; + ledger::confirm_parts( + connection, + self.frame.header.actor, + self.frame.header.operation, + self.frame.parts_witness, + self.frame.header.parts, + ) + .await?; + let count: i64 = sqlx::query_scalar( + "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?", + ) + .bind(self.frame.header.actor.participant().as_bytes().as_slice()) + .bind(self.frame.header.operation.as_bytes().as_slice()) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if count != self.movements.len() as i64 { + return Err(OperationError::RecoveryRequired); + } + for movement in &self.movements { + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_movements WHERE movement_id=? AND actor=? AND grant_id=? AND operation_id=? AND pool_id=? AND protected=?").bind(movement.id.as_slice()).bind(self.frame.header.actor.participant().as_bytes().as_slice()).bind(movement.grant.as_bytes().as_slice()).bind(self.frame.header.operation.as_bytes().as_slice()).bind(movement.pool.as_bytes().as_slice()).bind(&movement.protected).fetch_one(&mut *connection).await.map_err(|_| OperationError::RecoveryRequired)?; + if count != 1 { + return Err(OperationError::RecoveryRequired); + } + } + let count: i64 = sqlx::query_scalar( + "SELECT count(*) FROM stock_orders WHERE order_id=? AND revision=1 AND protected=?", + ) + .bind(self.receipt.order.as_bytes().as_slice()) + .bind(&self.order_cipher) + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if count != 1 { + return Err(OperationError::RecoveryRequired); + } + Ok(()) + } + pub fn into_history(self) -> ledger::HistoryEntry { + ledger::HistoryEntry { + header: self.frame.header, + protected: self.frame.protected, + parts_witness: self.frame.parts_witness, + pools: self.receipt.pools, + mapping: None, + movements: self.movements, + } + } +} +pub(super) fn receipt( + input: &AttachmentInput, + header: &ledger::Header, + body: &Body, + command: &CapturedOrderAcceptance, +) -> Result<StockAcceptanceReceipt, OperationError> { + Ok(StockAcceptanceReceipt { + attempt: CommitAttempt::new( + input.workspace_id(), + header.operation, + header.digest, + Some(header.transaction), + ), + order: header.order.ok_or(OperationError::RecoveryRequired)?, + request: command.input().request(), + terms: command.input().terms_digest(), + checkpoint: InventoryCheckpointRef::from_host_metadata( + input.authority(), + header.revision, + Some(header.head), + )? + .with_authorization(body.authorization), + pools: body.effects.iter().map(|value| value.after()).collect(), + allocations: body.allocations.len(), + observed: body.observed_at, + issue_before: body.issue_before, + }) +} +pub(in crate::workspace::stock) async fn read( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + operation: OperationId, +) -> Result<Option<Retained>, OperationError> { + let Some(frame) = ledger::read(connection, input, crypto, operation).await? else { + return Ok(None); + }; + if frame.header.family != ledger::Family::Acceptance { + return Err(OperationError::IdempotencyConflict); + } + let body: Body = super::super::super::closed_record(&frame.body) + .map_err(|_| OperationError::RecoveryRequired)?; + let command = CapturedOrderAcceptance::parse(body.command.get().as_bytes()) + .map_err(|_| OperationError::RecoveryRequired)?; + let terms = radroots_protocol::terms::decode(body.terms.get().as_bytes()) + .map_err(|_| OperationError::RecoveryRequired)?; + let encoded = radroots_protocol::terms::EncodedTerms::capture(&terms) + .map_err(|_| OperationError::RecoveryRequired)?; + let original = radroots_protocol::commerce::decode(body.original_request.get().as_bytes()) + .map_err(|_| OperationError::RecoveryRequired)?; + let radroots_domain::CommercePayload::Request(original_request) = original.content().payload() + else { + return Err(OperationError::RecoveryRequired); + }; + if original.record_id() != command.input().request() + || original_request.terms() != &terms + || original.content().header().order_id() + != command.context().expected().map(|value| value.order_id()) + || original.content().header().author() != terms.buyer() + || original.content().header().created_at() > body.observed_at + || body.expires > original_request.expires_at() + || original_request.quote().is_some() != body.original_quote.is_some() + { + return Err(OperationError::RecoveryRequired); + } + if let Some(raw) = body.original_quote { + let quoted = radroots_protocol::commerce::decode(raw.get().as_bytes()) + .map_err(|_| OperationError::RecoveryRequired)?; + let radroots_domain::CommercePayload::Quote(quote) = quoted.content().payload() else { + return Err(OperationError::RecoveryRequired); + }; + if Some(quoted.record_id()) != original_request.quote() + || quote.terms() != &terms + || body.expires > quote.expires_at() + || quoted.content().header().thread_id() != original.content().header().thread_id() + || quoted.content().header().buyer() != terms.buyer() + || quoted.content().header().seller() != terms.seller() + || quoted.content().header().created_at() > body.observed_at + { + return Err(OperationError::RecoveryRequired); + } + } + let expected = command + .context() + .expected() + .ok_or(OperationError::RecoveryRequired)?; + let header = &frame.header; + if body.version != 1 + || (body.seller_author_sequence.get() == 0) != body.seller_author_head.is_none() + || body.minimum_revision >= header.revision + || (body.minimum_revision.get() == 0) != body.minimum_head.is_none() + || header.operation != command.context().operation_id() + || header.actor != command.context().actor() + || header.digest != command.digest() + || command.context().workspace_id() != input.workspace_id() + || command.context().authority() != input.authority() + || command.context().route_digest() != input.route_digest() + || header.order != Some(expected.order_id()) + || expected.agreement().is_some() + || expected.seller_sequence().get() != 0 + || expected.checkpoint() != &body.coverage + || expected.buyer_head() != body.buyer_head + || encoded.digest() != command.input().terms_digest() + || terms.seller() != header.actor.participant() + || body.observed_at.get() == 0 + || body.expires <= body.observed_at + || body.issue_before <= body.observed_at + || body.issue_before > body.expires + || body.issue_before.get() - body.observed_at.get() > 120 + || body.expires > command.context().not_after() + || command.context().approval().is_none_or(|approval| { + approval.scope() != "orders.accept" + || approval.intent_digest() != command.approval_intent_digest() + || body.expires > approval.expires_at() + }) + || body.source_minimum.authorization != body.authorization + || body.listing_minimum.authorization != body.authorization + || body.source_minimum.authority != input.authority() + || body.listing_minimum.authority != input.authority() + || (body.source_minimum.revision.get() == 0) != body.source_minimum.head.is_none() + || (body.listing_minimum.revision.get() == 0) != body.listing_minimum.head.is_none() + || body.movements.len() != body.effects.len() + || body + .movements + .iter() + .copied() + .collect::<BTreeSet<_>>() + .len() + != body.movements.len() + || body.effects.len() > 64 + || body.allocations.len() > 64 + || body.mappings.len() > 32 + || body.pools.len() > 96 + || head(header, &frame.body) != header.head + { + return Err(OperationError::RecoveryRequired); + } + let (allocations, effects) = plan::resolve(&terms, &command, &body.mappings, &body.pools) + .map_err(|_| OperationError::RecoveryRequired)?; + if allocations != body.allocations || effects != body.effects { + return Err(OperationError::RecoveryRequired); + } + let expected_fence = fence(header, &command)?; + let row = sqlx::query("SELECT revision,protected FROM stock_orders WHERE order_id=? AND length(protected) BETWEEN 1 AND 262144").bind(expected_fence.order.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_| OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + let revision: i64 = row + .try_get(0) + .map_err(|_| OperationError::RecoveryRequired)?; + let order_cipher: Vec<u8> = row + .try_get(1) + .map_err(|_| OperationError::RecoveryRequired)?; + let clear = crypto + .open_stock_record( + input, + "order", + expected_fence.order.as_bytes(), + &order_cipher, + ) + .await?; + let order: Fence = clear + .expose_secret(|bytes| super::super::super::closed_record(bytes)) + .map_err(|_| OperationError::RecoveryRequired)?; + if revision != 1 || order != expected_fence { + return Err(OperationError::RecoveryRequired); + } + let mut movements = Vec::new(); + let grant = header + .actor + .grant_id() + .ok_or(OperationError::RecoveryRequired)?; + for (id, effect) in body.movements.iter().zip(&body.effects) { + let protected: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_movements WHERE movement_id=? AND actor=? AND grant_id=? AND operation_id=? AND pool_id=? AND length(protected) BETWEEN 1 AND 262144").bind(id.as_slice()).bind(header.actor.participant().as_bytes().as_slice()).bind(grant.as_bytes().as_slice()).bind(operation.as_bytes().as_slice()).bind(effect.before().id().as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_| OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + let clear = crypto + .open_stock_record(input, "acceptance_movement", id, &protected) + .await?; + let hold: Hold = clear + .expose_secret(|bytes| super::super::super::closed_record(bytes)) + .map_err(|_| OperationError::RecoveryRequired)?; + if hold + != (Hold { + version: 1, + operation, + digest: header.digest, + order: expected_fence.order, + effect: *effect, + }) + { + return Err(OperationError::RecoveryRequired); + } + movements.push(ledger::MovementWitness { + id: *id, + pool: effect.before().id(), + grant, + protected, + }); + } + movements.sort_by_key(|value| value.id); + let retained = Retained { + receipt: receipt(input, header, &body, &command)?, + frame, + movements, + order_cipher, + }; + retained.confirm(connection).await?; + Ok(Some(retained)) +} diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/acceptance/plan.rs b/crates/storage_sqlite/src/workspace/stock/inventory/acceptance/plan.rs @@ -0,0 +1,41 @@ +//! Store-neutral planning adapter. Domain owns all allocation/conservation rules. +use super::*; +pub(super) use radroots_domain::stock::{ + PoolHoldProposal as Effect, StockAllocation as Allocation, +}; +pub(super) fn resolve( + terms: &radroots_domain::Terms, + command: &CapturedOrderAcceptance, + mappings: &[radroots_domain::stock::OptionPoolMapping], + pools: &[PoolSnapshot], +) -> Result<(Vec<Allocation>, Vec<Effect>), OperationError> { + use radroots_domain::stock::{AllocationClaim, AllocationPlanError}; + let explicit = command + .input() + .allocation() + .explicit_allocations() + .map(|values| { + values + .iter() + .map(|value| { + AllocationClaim::new( + value.line_id(), + value.pool_id(), + value.quantity(), + value.expected_pool_version(), + ) + }) + .collect::<Result<Vec<_>, _>>() + }) + .transpose() + .map_err(|_| OperationError::InvalidCommand)?; + radroots_domain::stock::plan_allocations(terms, mappings, pools, explicit.as_deref()).map_err( + |error| match error { + AllocationPlanError::InvalidInput => OperationError::InvalidCommand, + AllocationPlanError::StaleState => OperationError::StaleState, + AllocationPlanError::Unsupported => OperationError::UnsupportedOperation, + AllocationPlanError::Capacity => WorkspaceError::Capacity.into(), + _ => OperationError::RecoveryRequired, + }, + ) +} diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs b/crates/storage_sqlite/src/workspace/stock/inventory/checkpoint.rs @@ -94,6 +94,57 @@ fn history_hash(multipart: bool) -> Sha256 { hash.update([u8::from(multipart)]); hash } +/// Initial decisions must prove absence through authenticated effects, rather +/// than trusting the mutable order index or its current row count alone. +pub(super) async fn authenticate_order_absence( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + binding: &WorkspaceBinding, + authority: &Authority, + order: radroots_domain::OrderId, +) -> Result<MinimumProof, OperationError> { + let current = authority + .inventory + .ok_or(OperationError::UnsupportedOperation)?; + if authority.catalog != 9 { + return Err(OperationError::UnsupportedOperation); + } + let upper = current.revision.get(); + let mut previous = current.head; + let mut hash = history_hash(true); + for revision in (1..=upper).rev() { + let id: Vec<u8> = sqlx::query_scalar("SELECT operation_id FROM stock_operations WHERE revision=? AND length(operation_id)=32") + .bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_| OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; + let operation = OperationId::from_bytes( + id.try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let entry = + super::super::ledger::history(connection, input, crypto, binding, authority, operation) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if entry.header.revision.get() != revision || Some(entry.header.head) != previous { + return Err(OperationError::RecoveryRequired); + } + if entry.header.family == super::super::ledger::Family::Acceptance + && entry.header.order == Some(order) + { + return Err(OperationError::StaleState); + } + entry.hash(&mut hash)?; + previous = entry.header.previous; + } + if previous.is_some() { + return Err(OperationError::RecoveryRequired); + } + Ok(MinimumProof { + lower: 1, + upper, + digest: hash.finalize().into(), + multipart: true, + }) +} #[derive(Clone, Copy, Eq, PartialEq)] pub(in crate::workspace::stock) struct EntryIdentity { pub operation: OperationId, @@ -120,7 +171,7 @@ pub(in crate::workspace::stock) async fn authenticate_identity( let current = authority .inventory .ok_or(OperationError::UnsupportedOperation)?; - let multipart = matches!(authority.catalog, 7 | 8); + let multipart = matches!(authority.catalog, 7..=9); let upper = current.revision.get(); let mut previous = current.head; let mut hash = history_hash(multipart); @@ -233,7 +284,7 @@ pub(super) async fn authenticate_minimum( } let lower = minimum.revision().get().max(1); let upper = current.revision.get(); - let multipart = matches!(authority.catalog, 7 | 8); + let multipart = matches!(authority.catalog, 7..=9); let mut hash = history_hash(multipart); let mut expected = current.head; for revision in (lower..=upper).rev() { @@ -481,7 +532,7 @@ async fn authenticate_projected( .ok_or(OperationError::UnsupportedOperation)?; let upper = current.revision.get(); let mut expected = current.head; - let multipart = matches!(authority.catalog, 7 | 8); + let multipart = matches!(authority.catalog, 7..=9); let mut hash = history_hash(multipart); for revision in (1..=upper).rev() { let id:Vec<u8>=sqlx::query_scalar("SELECT operation_id FROM stock_operations WHERE revision=? AND length(operation_id)=32").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/codec.rs @@ -120,7 +120,7 @@ pub(super) fn encode_operation( String::from_utf8(clear.to_vec()).map_err(|_| OperationError::StorageFailure)?, ) .map_err(|_| OperationError::StorageFailure)?; - if matches!(catalog, 5..=8) { + if matches!(catalog, 5..=9) { return super::encode(&OperationV4 { version: 4, authorization: authorization.ok_or(OperationError::RecoveryRequired)?, @@ -158,7 +158,7 @@ fn decode_inner( catalog: i64, allow_mapping: bool, ) -> Result<(InventoryRequest, OperationData), OperationError> { - if matches!(catalog, 5..=8) { + if matches!(catalog, 5..=9) { let decoded: OperationV4<'_> = super::closed_record(bytes).map_err(|_| OperationError::RecoveryRequired)?; if decoded.version != 4 { diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/mapping.rs b/crates/storage_sqlite/src/workspace/stock/inventory/mapping.rs @@ -58,7 +58,7 @@ impl MappingRead { } } pub(super) fn require(access: &Access, key: OptionMappingKey) -> Result<(), OperationError> { - if !(5..=8).contains(&access.authority.catalog) { + if !(5..=9).contains(&access.authority.catalog) { return Err(OperationError::UnsupportedOperation); } if !access.record.administrator() diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs b/crates/storage_sqlite/src/workspace/stock/inventory/plan.rs @@ -3,7 +3,7 @@ use super::*; pub(super) fn record_version(catalog: i64) -> Result<u8, OperationError> { match catalog { 2 => Ok(1), - 3..=8 => Ok(2), + 3..=9 => Ok(2), _ => Err(OperationError::RecoveryRequired), } } diff --git a/crates/storage_sqlite/src/workspace/stock/ledger.rs b/crates/storage_sqlite/src/workspace/stock/ledger.rs @@ -485,6 +485,12 @@ pub(super) async fn history( movements: vec![], })) } + Some(2) if authority.catalog == 9 => Ok(Some( + super::inventory::acceptance::codec::read(connection, input, crypto, operation) + .await? + .ok_or(OperationError::RecoveryRequired)? + .into_history(), + )), Some(2) => Err(OperationError::UnsupportedOperation), Some(_) => Err(OperationError::RecoveryRequired), } diff --git a/crates/storage_sqlite/src/workspace/stock/public_source.rs b/crates/storage_sqlite/src/workspace/stock/public_source.rs @@ -8,6 +8,7 @@ use radroots_domain::{ use radroots_event::envelope::event_head::EventHeadCoordinate; use radroots_nostr::public_ingress::ObservedHead; use zeroize::Zeroizing; +pub(in crate::workspace::stock) mod admission; mod checkpoint; pub(in crate::workspace::stock) mod history; mod record; diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/acceptance_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/acceptance_tests.rs @@ -0,0 +1,791 @@ +//! Actual T0 effects on the native connection, with independent original sources. +use super::*; +use crate::workspace::{ + StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, StockConsentCapture, + StockConsentMode, StockConsentOutcome, +}; +use radroots_domain::{CommandContextData, OperationId, PoolId}; +use radroots_protocol::command::CapturedOrderAcceptance; +use radroots_storage::{ + inventory::{InventoryOutcome, InventoryRequest, InventoryStore}, + workspace::seller_stock::StockResources, +}; + +fn pool(id: u8) -> PoolId { + PoolId::from_bytes([id; 32]) +} +async fn inventory_minimum(r: &Rig) -> radroots_storage::inventory::InventoryCheckpointRef { + r.store + .stock_authority(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap() + .inventory_checkpoint() + .unwrap() +} +fn context(r: &Rig, id: u8) -> CommandContextData { + CommandContextData::new( + OperationId::from_bytes([id; 32]), + r.binding.actor(), + r.enrollment.input().workspace_id(), + r.enrollment.input().authority(), + r.enrollment.input().route_digest(), + None, + None, + UnixSeconds::new(230).unwrap(), + None, + ) + .unwrap() +} +async fn physical(r: &Rig, wire: serde_json::Value) { + let request = InventoryRequest::from_protected_wire( + r.binding.clone(), + inventory_minimum(r).await, + &serde_json::to_vec(&wire).unwrap(), + ) + .unwrap(); + let proof = r + .enrollment + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap(); + assert!(matches!( + r.store.execute_inventory(request, proof).await.unwrap(), + InventoryOutcome::Committed(_) + )); +} +async fn seed(r: &Rig, amount: &str) { + base(r).await; + for id in [80, 81] { + physical(r, serde_json::json!({"type":"stock.create_pool","context":context(r,id),"input":{"id":pool(id),"label":"private bunch-equivalent","unit":"each","tick_scale":"0","initial_quantity":amount}})).await; + } + let inspected = inspect(r).await; + let line = &inspected.terms().lines()[0]; + physical(r, serde_json::json!({"type":"stock.map_option","context":context(r,82),"input":{"listing":line.source().coordinate(),"option_id":line.option_id(),"pool_id":pool(80),"expected_mapping_version":"0","per_sale_unit":{"amount":"1","unit":"each"}}})).await; +} +async fn inspect(r: &Rig) -> StockRequestSnapshot { + let (private, public) = minima(r).await; + r.store + .stock_order_request( + r.binding.clone(), + private, + public, + identity("request"), + r.enrollment.proof(), + ) + .await + .unwrap() +} +async fn command(r: &Rig, id: u8, explicit: bool) -> CapturedOrderAcceptance { + let snapshot = inspect(r).await; + command_snapshot(r, id, explicit, &snapshot) +} +fn command_snapshot( + r: &Rig, + id: u8, + explicit: bool, + snapshot: &StockRequestSnapshot, +) -> CapturedOrderAcceptance { + let mut allocation = serde_json::json!({"type":"automatic"}); + if explicit { + allocation = serde_json::json!({"type":"explicit","allocations":[{"line_id":snapshot.terms().lines()[0].id(),"pool_id":pool(80),"quantity":{"amount":"1","unit":"each"},"expected_pool_version":"1"},{"line_id":snapshot.terms().lines()[0].id(),"pool_id":pool(81),"quantity":{"amount":"2","unit":"each"},"expected_pool_version":"1"}]}); + } + let mut value = serde_json::json!({"type":"orders.accept","context":context(r,id),"input":{"request":snapshot.request(),"terms_digest":snapshot.terms_digest(),"allocation":allocation}}); + 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 captured = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap(); + value["context"]["approval"] = serde_json::json!({"intent_digest":captured.approval_intent_digest(),"scope":"orders.accept","expires_at":"230"}); + CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap() +} +async fn inspect_named(r: &Rig, name: &str) -> StockRequestSnapshot { + let selected: RecordId = data()["sources"] + .as_array() + .unwrap() + .iter() + .find(|row| row["name"] == name) + .unwrap()["record_id"] + .as_str() + .unwrap() + .parse() + .unwrap(); + let (private, public) = minima(r).await; + r.store + .stock_order_request( + r.binding.clone(), + private, + public, + selected, + r.enrollment.proof(), + ) + .await + .unwrap() +} +async fn consent(r: &Rig, command: &CapturedOrderAcceptance) { + let scope = StockConsentCapture::prepare( + SellerAuthoritySelection::from_attachment(r.enrollment.input()), + r.enrollment.input().grant_id(), + StockConsentMode::ExecuteAndRecover, + StockResources::all_pools(), + UnixSeconds::new(230).unwrap(), + CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), + ) + .unwrap(); + assert!(matches!( + r.store + .issue_stock_consent( + r.binding.clone(), + inventory_minimum(r).await, + &scope, + r.enrollment.proof() + ) + .await + .unwrap(), + StockConsentOutcome::Committed(_) + )); +} +async fn request(r: &Rig, command: &CapturedOrderAcceptance) -> StockAcceptanceRequest { + let (private, public) = minima(r).await; + StockAcceptanceRequest::capture( + r.binding.clone(), + inventory_minimum(r).await, + private, + public, + command, + ) + .unwrap() +} +async fn prepare( + r: &Rig, + command: &CapturedOrderAcceptance, +) -> Result<StockAcceptanceReceipt, OperationError> { + match r + .store + .prepare_stock_acceptance(request(r, command).await, r.enrollment.proof()) + .await? + { + StockAcceptanceOutcome::Prepared(value) => Ok(*value), + _ => panic!("T0 must confirm"), + } +} +async fn assert_pool(r: &Rig, id: u8, available: u64, held: u64, version: u64) { + let value = r + .store + .pool( + r.binding.clone(), + inventory_minimum(r).await, + pool(id), + r.enrollment + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap(), + ) + .await + .unwrap() + .unwrap(); + let snapshot = value.snapshot(); + assert_eq!(snapshot.version().get(), version); + assert_eq!(snapshot.balances().physical().available.get(), available); + assert_eq!(snapshot.balances().physical().preparatory_hold.get(), held); + assert_eq!(snapshot.balances().introduced().get(), available + held); +} +#[tokio::test] +async fn actual_automatic_hold_retains_one_original_and_reopens_before_fresh_withdrawal_or_allocation() + { + let mut r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, false).await; + consent(&r, &command).await; + let original = prepare(&r, &command).await.unwrap(); + assert_eq!(original.held_pools().len(), 1); + assert_eq!(original.allocation_count(), 1); + assert_pool(&r, 80, 7, 3, 2).await; + assert_pool(&r, 81, 10, 0, 1).await; + retain(&r, "withdrawal").await; + let replay = prepare(&r, &command).await.unwrap(); + assert_eq!(replay.attempt(), original.attempt()); + assert_eq!(replay.checkpoint(), original.checkpoint()); + r.store.close().await.unwrap(); + r.store = NativeWorkspace::open_seller_stock( + &r.path, + r.enrollment.input().clone(), + r.fixture.crypto(), + r.clock.clone(), + ) + .await + .unwrap(); + assert_eq!( + prepare(&r, &command).await.unwrap().attempt(), + original.attempt() + ); + assert_pool(&r, 80, 7, 3, 2).await; + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn actual_explicit_two_pool_hold_is_complete_and_second_decision_cannot_reuse_order() { + let r = Rig::new().await; + seed(&r, "10").await; + let first = command(&r, 90, true).await; + let second = command(&r, 91, false).await; + consent(&r, &first).await; + consent(&r, &second).await; + let receipt = prepare(&r, &first).await.unwrap(); + assert_eq!(receipt.held_pools().len(), 2); + assert_eq!(receipt.allocation_count(), 2); + assert_pool(&r, 80, 9, 1, 2).await; + assert_pool(&r, 81, 8, 2, 2).await; + assert_eq!( + prepare(&r, &second).await.unwrap_err().code(), + "stale_state" + ); + assert_pool(&r, 80, 9, 1, 2).await; + assert_pool(&r, 81, 8, 2, 2).await; + let mut raw = database(&r).await; + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_orders") + .fetch_one(&mut raw) + .await + .unwrap(), + 1 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_operations WHERE family=2") + .fetch_one(&mut raw) + .await + .unwrap(), + 1 + ); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn insufficient_complete_allocation_changes_no_pool_and_writes_no_fence_or_operation() { + let r = Rig::new().await; + seed(&r, "1").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let before = inventory_minimum(&r).await; + assert_eq!( + prepare(&r, &command).await.unwrap_err().code(), + "stale_state" + ); + assert_eq!(inventory_minimum(&r).await, before); + assert_pool(&r, 80, 1, 0, 1).await; + assert_pool(&r, 81, 1, 0, 1).await; + let mut raw = database(&r).await; + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_orders") + .fetch_one(&mut raw) + .await + .unwrap(), + 0 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_operations WHERE family=2") + .fetch_one(&mut raw) + .await + .unwrap(), + 0 + ); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); +} +#[tokio::test] +async fn unissued_capture_or_physical_inventory_rights_do_not_authorize_acceptance() { + let r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, false).await; + assert_eq!( + prepare(&r, &command).await.unwrap_err().code(), + "unauthorized" + ); + assert_pool(&r, 80, 10, 0, 1).await; + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn each_actual_write_failure_rolls_back_all_pool_holds_and_order_fence() { + for statement in [ + "CREATE TRIGGER fault BEFORE INSERT ON stock_operations WHEN NEW.family=2 BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE INSERT ON stock_operation_parts BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE UPDATE ON stock_pools WHEN hex(NEW.pool_id)=replace(hex(zeroblob(32)),'00','51') BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE INSERT ON stock_movements BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE INSERT ON stock_orders BEGIN SELECT RAISE(ABORT,'fixture'); END", + "CREATE TRIGGER fault BEFORE UPDATE ON stock_authority BEGIN SELECT RAISE(ABORT,'fixture'); END", + ] { + let r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let before = inventory_minimum(&r).await; + let mut raw = database(&r).await; + sqlx::raw_sql(statement).execute(&mut raw).await.unwrap(); + assert_eq!( + prepare(&r, &command).await.unwrap_err().code(), + "storage_failure" + ); + assert_eq!(inventory_minimum(&r).await, before); + assert_pool(&r, 80, 10, 0, 1).await; + assert_pool(&r, 81, 10, 0, 1).await; + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_orders") + .fetch_one(&mut raw) + .await + .unwrap(), + 0 + ); + sqlx::raw_sql("DROP TRIGGER fault") + .execute(&mut raw) + .await + .unwrap(); + assert_eq!(prepare(&r, &command).await.unwrap().held_pools().len(), 2); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn actual_commit_failure_returns_original_identity_and_requires_drain_before_recovery() { + let mut r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let before = inventory_minimum(&r).await; + let (private, public) = minima(&r).await; + let mut raw = database(&r).await; + sqlx::raw_sql("CREATE TABLE deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER fault AFTER INSERT ON stock_orders BEGIN INSERT INTO deferred_fault VALUES(2); END").execute(&mut raw).await.unwrap(); + let StockAcceptanceOutcome::Unknown(attempt) = r + .store + .prepare_stock_acceptance(request(&r, &command).await, r.enrollment.proof()) + .await + .unwrap() + else { + panic!("COMMIT must be uncertain"); + }; + assert_eq!(attempt.operation_id(), command.context().operation_id()); + assert_eq!(attempt.command_digest(), command.digest()); + assert!(attempt.transaction_id().is_some()); + assert_eq!( + r.store + .prepare_stock_acceptance( + StockAcceptanceRequest::capture( + r.binding.clone(), + before, + private, + public, + &command + ) + .unwrap(), + r.enrollment.proof() + ) + .await + .unwrap_err() + .code(), + "recovery_required" + ); + r.store.close().await.unwrap(); + sqlx::raw_sql("DROP TRIGGER fault; DROP TABLE deferred_fault") + .execute(&mut raw) + .await + .unwrap(); + raw.close().await.unwrap(); + r.store = NativeWorkspace::open_seller_stock( + &r.path, + r.enrollment.input().clone(), + r.fixture.crypto(), + r.clock.clone(), + ) + .await + .unwrap(); + assert_eq!(inventory_minimum(&r).await, before); + assert_pool(&r, 80, 10, 0, 1).await; + assert_pool(&r, 81, 10, 0, 1).await; + assert_eq!(prepare(&r, &command).await.unwrap().held_pools().len(), 2); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn lost_observer_retains_actual_two_pool_preparation_and_drain_precedes_reopen() { + let mut r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let request = request(&r, &command).await; + let provider = reopen(&mut r).await; + provider + .gate + .arm(Direction::Wrap, "radroots.seller_stock.authority.v9", 0); + let mut pending = Box::pin( + r.store + .prepare_stock_acceptance(request, r.enrollment.proof()), + ); + assert!(futures::poll!(pending.as_mut()).is_pending()); + provider.gate.entered(); + drop(pending); + assert!(matches!( + NativeWorkspace::open_seller_stock( + &r.path, + r.enrollment.input().clone(), + r.fixture.crypto(), + r.clock.clone() + ) + .await, + Err(WorkspaceError::WriterActive) + )); + provider.gate.release(); + r.store.close().await.unwrap(); + r.store = NativeWorkspace::open_seller_stock( + &r.path, + r.enrollment.input().clone(), + r.fixture.crypto(), + r.clock.clone(), + ) + .await + .unwrap(); + assert_eq!(prepare(&r, &command).await.unwrap().held_pools().len(), 2); + assert_pool(&r, 80, 9, 1, 2).await; + assert_pool(&r, 81, 8, 2, 2).await; + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn source_mapping_pool_order_and_grant_rows_are_rechecked_after_final_provider_io() { + for statement in [ + "UPDATE stock_pools SET protected=randomblob(length(protected))", + "UPDATE stock_mappings SET revision=revision+1", + "UPDATE stock_source_records SET protected=randomblob(length(protected))", + "INSERT INTO stock_source_records(record_id,protected) VALUES(randomblob(32),x'01')", + "UPDATE stock_public_heads SET protected=randomblob(length(protected))", + "UPDATE stock_grants SET protected=randomblob(length(protected))", + "INSERT INTO stock_orders(order_id,revision,protected) VALUES(randomblob(32),1,x'01')", + ] { + let mut r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let request = request(&r, &command).await; + let provider = reopen(&mut r).await; + let mut raw = database(&r).await; + provider + .gate + .arm(Direction::Wrap, "radroots.seller_stock.authority.v9", 0); + let mut pending = Box::pin( + r.store + .prepare_stock_acceptance(request, r.enrollment.proof()), + ); + assert!(futures::poll!(pending.as_mut()).is_pending()); + provider.gate.entered(); + sqlx::raw_sql(statement).execute(&mut raw).await.unwrap(); + provider.gate.release(); + assert_eq!( + pending.await.unwrap_err().code(), + "recovery_required", + "{statement}" + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_operations WHERE family=2") + .fetch_one(&mut raw) + .await + .unwrap(), + 0 + ); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn final_clock_recheck_refuses_expiry_and_rollback_after_protection_without_reserving() { + for at in [149, 230, 300] { + let mut r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let request = request(&r, &command).await; + let provider = reopen(&mut r).await; + provider + .gate + .arm(Direction::Wrap, "radroots.seller_stock.authority.v9", 0); + let mut pending = Box::pin( + r.store + .prepare_stock_acceptance(request, r.enrollment.proof()), + ); + assert!(futures::poll!(pending.as_mut()).is_pending()); + provider.gate.entered(); + r.clock.0.store(at, Ordering::SeqCst); + provider.gate.release(); + let error = pending.await.unwrap_err(); + assert_eq!( + error.code(), + match at { + 149 => "workspace_unavailable", + 230 => "deadline_exceeded", + _ => "grant_expired", + } + ); + r.clock.0.store(150, Ordering::SeqCst); + assert_pool(&r, 80, 10, 0, 1).await; + assert_pool(&r, 81, 10, 0, 1).await; + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn competing_orders_share_one_pool_and_cannot_both_acquire_its_last_available_stock() { + let r = Rig::new().await; + seed(&r, "4").await; + retain(&r, "request_other_order").await; + let first = command(&r, 90, false).await; + let second = command_snapshot( + &r, + 91, + false, + &inspect_named(&r, "request_other_order").await, + ); + consent(&r, &first).await; + consent(&r, &second).await; + let a = request(&r, &first).await; + let b = request(&r, &second).await; + let (a, b) = futures::join!( + r.store.prepare_stock_acceptance(a, r.enrollment.proof()), + r.store.prepare_stock_acceptance(b, r.enrollment.proof()) + ); + assert!(matches!(a.unwrap(), StockAcceptanceOutcome::Prepared(_))); + assert_eq!(b.unwrap_err().code(), "stale_state"); + assert_pool(&r, 80, 1, 3, 2).await; + let mut raw = database(&r).await; + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_orders") + .fetch_one(&mut raw) + .await + .unwrap(), + 1 + ); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn explicitly_authorized_future_promise_fences_the_order_without_inventing_a_stock_hold() { + let r = Rig::new().await; + r.retain(&r.capture("listing_fixed")).await; + retain(&r, "request_future_promise").await; + let snapshot = inspect_named(&r, "request_future_promise").await; + let command = command_snapshot(&r, 90, false, &snapshot); + consent(&r, &command).await; + let receipt = prepare(&r, &command).await.unwrap(); + assert!(receipt.held_pools().is_empty()); + assert_eq!(receipt.allocation_count(), 0); + assert_eq!( + prepare(&r, &command).await.unwrap().attempt(), + receipt.attempt() + ); + let mut raw = database(&r).await; + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_pools") + .fetch_one(&mut raw) + .await + .unwrap(), + 0 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_movements") + .fetch_one(&mut raw) + .await + .unwrap(), + 0 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT count(*) FROM stock_orders") + .fetch_one(&mut raw) + .await + .unwrap(), + 1 + ); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn variable_weight_reserves_the_whole_authorized_line_maximum_using_explicit_units() { + let r = Rig::new().await; + r.retain(&r.capture("listing_fixed")).await; + retain(&r, "request_variable_weight").await; + physical(&r,serde_json::json!({"type":"stock.create_pool","context":context(&r,80),"input":{"id":pool(80),"label":"measured produce","unit":"kg","tick_scale":"3","initial_quantity":"10"}})).await; + let snapshot = inspect_named(&r, "request_variable_weight").await; + let line = &snapshot.terms().lines()[0]; + physical(&r,serde_json::json!({"type":"stock.map_option","context":context(&r,82),"input":{"listing":line.source().coordinate(),"option_id":line.option_id(),"pool_id":pool(80),"expected_mapping_version":"0","per_sale_unit":{"amount":"0.5","unit":"kg"}}})).await; + let command = command_snapshot(&r, 90, false, &snapshot); + consent(&r, &command).await; + let receipt = prepare(&r, &command).await.unwrap(); + assert_eq!(receipt.held_pools().len(), 1); + // Three nominal bunches at0.5kg are1.5kg; this request authorizes an + // entire line maximum of2kg, which is the actual preparatory backing. + assert_pool(&r, 80, 8000, 2000, 2).await; + assert_eq!( + prepare(&r, &command).await.unwrap().attempt(), + receipt.attempt() + ); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn current_recovery_only_consent_recovers_original_after_deadlines_without_fresh_holds() { + let r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, true).await; + consent(&r, &command).await; + let original = prepare(&r, &command).await.unwrap(); + r.clock.0.store(250, Ordering::SeqCst); + let child = StockGrantEnrollment::prepare( + &SellerAuthoritySelection::from_attachment(r.enrollment.input()), + "recovery operator".into(), + UnixSeconds::new(290).unwrap(), + StockGrantScope::full_inventory(), + ) + .unwrap(); + assert!(matches!( + r.store + .enroll_stock_grant( + r.binding.clone(), + inventory_minimum(&r).await, + r.enrollment.proof(), + &child + ) + .await + .unwrap(), + StockGrantOutcome::Committed(_) + )); + let binding = r + .store + .authenticate(child.input().clone(), child.proof()) + .await + .unwrap(); + 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(); + assert!(matches!( + r.store + .issue_stock_consent( + r.binding.clone(), + inventory_minimum(&r).await, + &capture, + r.enrollment.proof() + ) + .await + .unwrap(), + StockConsentOutcome::Committed(_) + )); + let (private, public) = minima(&r).await; + let request = StockAcceptanceRequest::capture( + binding, + inventory_minimum(&r).await, + private, + public, + &command, + ) + .unwrap(); + let StockAcceptanceOutcome::Prepared(recovered) = r + .store + .prepare_stock_acceptance(request, child.proof()) + .await + .unwrap() + else { + panic!(); + }; + assert_eq!(recovered.attempt(), original.attempt()); + assert_eq!(recovered.held_pools(), original.held_pools()); + assert_pool(&r, 80, 9, 1, 2).await; + assert_pool(&r, 81, 8, 2, 2).await; + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn recovery_only_scope_never_admits_a_missing_original_operation() { + let r = Rig::new().await; + seed(&r, "10").await; + let command = command(&r, 90, false).await; + let scope = StockConsentCapture::prepare( + SellerAuthoritySelection::from_attachment(r.enrollment.input()), + r.enrollment.input().grant_id(), + StockConsentMode::RecoverOnly, + StockResources::all_pools(), + UnixSeconds::new(230).unwrap(), + CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), + ) + .unwrap(); + assert!(matches!( + r.store + .issue_stock_consent( + r.binding.clone(), + inventory_minimum(&r).await, + &scope, + r.enrollment.proof() + ) + .await + .unwrap(), + StockConsentOutcome::Committed(_) + )); + assert_eq!( + prepare(&r, &command).await.unwrap_err().code(), + "unauthorized" + ); + assert_pool(&r, 80, 10, 0, 1).await; + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn explicit_incomplete_excess_unknown_line_incompatible_units_and_stale_versions_refuse_atomically() + { + for (path, value, code) in [ + ( + "/input/allocation/allocations/1/quantity/amount", + serde_json::json!("1"), + "invalid_command", + ), + ( + "/input/allocation/allocations/1/quantity/amount", + serde_json::json!("3"), + "invalid_command", + ), + ( + "/input/allocation/allocations/1/line_id", + serde_json::json!("fa".repeat(32)), + "invalid_command", + ), + ( + "/input/allocation/allocations/1/quantity/unit", + serde_json::json!("kg"), + "invalid_command", + ), + ( + "/input/allocation/allocations/1/expected_pool_version", + serde_json::json!("2"), + "stale_state", + ), + ] { + let r = Rig::new().await; + seed(&r, "10").await; + let original = command(&r, 90, true).await; + let mut raw: serde_json::Value = serde_json::from_slice(original.protected_wire()).unwrap(); + *raw.pointer_mut(path).unwrap() = value; + raw["context"]["approval"] = serde_json::Value::Null; + let unsigned = CapturedOrderAcceptance::parse(&serde_json::to_vec(&raw).unwrap()).unwrap(); + raw["context"]["approval"] = serde_json::json!({"intent_digest":unsigned.approval_intent_digest(),"scope":"orders.accept","expires_at":"230"}); + let command = CapturedOrderAcceptance::parse(&serde_json::to_vec(&raw).unwrap()).unwrap(); + consent(&r, &command).await; + let before = inventory_minimum(&r).await; + assert_eq!( + prepare(&r, &command).await.unwrap_err().code(), + code, + "{path}" + ); + assert_eq!(inventory_minimum(&r).await, before); + assert_pool(&r, 80, 10, 0, 1).await; + assert_pool(&r, 81, 10, 0, 1).await; + r.store.close().await.unwrap(); + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/admission.rs b/crates/storage_sqlite/src/workspace/stock/public_source/admission.rs @@ -0,0 +1,146 @@ +//! Original public snapshots and protected current-observed source checks. +//! The caller independently proves request/quote and current execution rights. +use super::*; +use radroots_domain::{AgreementLine, UnixSeconds, listing::ListingState}; +use radroots_storage::command::OperationError; + +pub(in crate::workspace::stock) struct ListingView { + source: ListingRevision, + original: checkpoint::Proof, + projection: checkpoint::Proof, + head: Option<record::RetainedHead>, + parts: u8, + parts_witness: [u8; 32], + listing: Box<radroots_protocol::listing::DecodedListing>, +} +pub(in crate::workspace::stock) async fn prepare( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + authority: &Authority, + source: ListingRevision, + observed_at: UnixSeconds, +) -> Result<ListingView, OperationError> { + let retained = record::read( + connection, + input, + crypto, + authority.input.grant_id(), + source.event_id(), + ) + .await?; + let original = checkpoint::authenticate( + connection, + input, + crypto, + authority, + checkpoint::Target::Event( + source.event_id(), + retained + .as_ref() + .map(|value| value.identity()) + .transpose()?, + ), + ) + .await?; + let retained = retained.ok_or(OperationError::MissingHistory)?; + if retained.header.manifest.listing != source { + return Err(OperationError::InvalidEvidence); + } + let parts = record::read_parts(connection, input, crypto, &retained.header).await?; + let head = record::read_head(connection, input, crypto, source.coordinate()).await?; + let projection = checkpoint::authenticate( + connection, + input, + crypto, + authority, + checkpoint::Target::Coordinate( + source.coordinate(), + head.as_ref().map(|value| value.head.clone()), + ), + ) + .await?; + let raw = std::str::from_utf8(&parts.raw).map_err(|_| OperationError::RecoveryRequired)?; + let mut observed = ObservedHead::listing( + source.coordinate().author(), + &source.coordinate().d().to_string(), + ) + .map_err(|_| OperationError::RecoveryRequired)?; + observed + .observe(raw) + .map_err(|_| OperationError::RecoveryRequired)?; + let meaning = observed + .interpret( + radroots_protocol::advertisement::UnixSeconds::new(observed_at.get()) + .map_err(|_| WorkspaceError::Unavailable)?, + ) + .ok_or(OperationError::RecoveryRequired)?; + let listing = match meaning { + radroots_nostr::public_ingress::Interpretation::Listing(listing) => listing, + radroots_nostr::public_ingress::Interpretation::ClockAhead => { + return Err(WorkspaceError::Unavailable.into()); + } + radroots_nostr::public_ingress::Interpretation::Unsupported => { + return Err(OperationError::UnsupportedOperation); + } + _ => return Err(OperationError::InvalidEvidence), + }; + Ok(ListingView { + source, + original, + projection, + head, + parts: retained.header.manifest.parts, + parts_witness: parts.witness, + listing, + }) +} +impl ListingView { + pub(in crate::workspace::stock) fn validate( + &self, + line: &AgreementLine, + explicit_quote: bool, + observed_at: UnixSeconds, + ) -> Result<(), OperationError> { + let listing = self.listing.listing(); + let terms = listing.terms(); + if listing.created_at() > observed_at { + return Err(WorkspaceError::Unavailable.into()); + } + if line.source() != self.source + || listing.source() != self.source + || line.product() != terms.product() + || terms + .options() + .iter() + .find(|option| option.id() == line.option_id()) + != Some(line.option()) + { + return Err(OperationError::InvalidEvidence); + } + if !explicit_quote + && (terms.state() != ListingState::Active + || !self + .head + .as_ref() + .is_some_and(|head| head.head.listing == self.source)) + { + return Err(OperationError::StaleState); + } + Ok(()) + } + pub(in crate::workspace::stock) async fn confirm( + &self, + connection: &mut SqliteConnection, + ) -> Result<(), OperationError> { + self.original.confirm(connection).await?; + self.projection.confirm(connection).await?; + record::confirm_head(connection, self.source.coordinate(), self.head.as_ref()).await?; + if record::parts_witness(connection, self.source.event_id()).await? + != (self.parts, self.parts_witness) + { + return Err(OperationError::RecoveryRequired); + } + Ok(()) + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/history_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/history_tests.rs @@ -1,6 +1,10 @@ //! Real NIP59/NIP44 source admission and actual native causal coverage. The //! independent producer does not call a Radroots record/envelope constructor. use super::*; +#[path = "acceptance_tests.rs"] +mod acceptance; +#[path = "request_tests.rs"] +mod requests; use radroots_domain::{ RecordId, SourceId, causal::{CausalReadiness, CausalScope}, @@ -143,6 +147,7 @@ async fn real_original_missing_sources_become_complete_only_after_exact_history_ let mut r = Rig::new().await; retain(&r, "request").await; let missing = history(&r).await; + assert!(missing.checkpoint().is_none()); assert_eq!( missing.analysis().readiness(), CausalReadiness::MissingHistory @@ -159,6 +164,8 @@ async fn real_original_missing_sources_become_complete_only_after_exact_history_ r.retain(&r.capture("listing_fixed")).await; let before = minima(&r).await; let complete = history(&r).await; + let coverage = complete.checkpoint().unwrap().clone(); + assert_eq!(coverage.sequence().get(), 4); assert_eq!(complete.analysis().readiness(), CausalReadiness::Complete); assert_eq!(complete.analysis().buyer_head(), Some(identity("request"))); assert_eq!(complete.analysis().quote_head(), Some(identity("quote"))); @@ -170,6 +177,7 @@ async fn real_original_missing_sources_become_complete_only_after_exact_history_ assert_eq!(minima(&r).await, before); retain(&r, "request_rewrapped").await; retain(&r, "unrelated").await; + assert_eq!(history(&r).await.checkpoint(), Some(&coverage)); assert_eq!(history(&r).await.analysis(), complete.analysis()); assert_eq!(history(&r).await.known_records(), 2); r.store.close().await.unwrap(); @@ -196,8 +204,13 @@ async fn actual_withdrawal_and_authenticated_author_fork_are_exposed_without_tim .await .unwrap() .inventory_checkpoint(); + let original_coverage = history(&r).await.checkpoint().unwrap().clone(); retain(&r, "withdrawal").await; let withdrawal = history(&r).await; + assert_ne!( + withdrawal.checkpoint().unwrap().digest(), + original_coverage.digest() + ); assert_eq!(withdrawal.analysis().readiness(), CausalReadiness::Complete); assert_eq!( withdrawal.analysis().buyer_head(), @@ -205,6 +218,7 @@ async fn actual_withdrawal_and_authenticated_author_fork_are_exposed_without_tim ); retain(&r, "buyer_fork").await; let fork = history(&r).await; + assert!(fork.checkpoint().is_none()); assert_eq!(fork.analysis().readiness(), CausalReadiness::Conflicted); assert_eq!(fork.analysis().buyer_head(), Some(identity("request"))); let mut expected = vec![identity("withdrawal"), identity("buyer_fork")]; @@ -259,6 +273,7 @@ async fn ordinary_chat_is_a_source_but_uninterpretable_authenticated_commerce_bl CausalReadiness::Uninterpreted ); assert_eq!(result.analysis().uninterpreted().len(), 1); + assert!(result.checkpoint().is_none()); assert!(result.analysis().missing().is_empty()); assert_eq!(result.analysis().buyer_head(), Some(identity("request"))); r.store.close().await.unwrap(); diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/request_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/request_tests.rs @@ -0,0 +1,258 @@ +//! Actual original request/source checks, not acceptance or physical reservation. +use super::*; + +fn selected(name: &str) -> RecordId { + data()["sources"] + .as_array() + .unwrap() + .iter() + .find(|row| row["name"] == name) + .unwrap()["record_id"] + .as_str() + .unwrap() + .parse() + .unwrap() +} +async fn inspect(r: &Rig, name: &str) -> Result<StockRequestSnapshot, OperationError> { + let (private, public) = minima(r).await; + r.store + .stock_order_request( + r.binding.clone(), + private, + public, + selected(name), + r.enrollment.proof(), + ) + .await +} +async fn seed(r: &Rig, name: &str, quote: bool) { + r.retain(&r.capture("listing_fixed")).await; + if quote { + retain(r, "chat").await; + retain(r, "quote").await; + } + retain(r, name).await; +} + +#[tokio::test] +async fn original_request_inspection_returns_exact_private_terms_without_stock_or_order_effects_and_reopens() + { + let mut r = Rig::new().await; + base(&r).await; + let before = minima(&r).await; + let snapshot = inspect(&r, "request").await.unwrap(); + assert_eq!(snapshot.request(), identity("request")); + assert_eq!(snapshot.scope(), scope()); + assert_eq!(snapshot.quote(), Some(identity("quote"))); + assert_eq!(snapshot.expires_at().get(), 240); + assert_eq!(snapshot.observed_at().get(), 150); + assert_eq!(snapshot.source_checkpoint(), before.0); + assert_eq!(snapshot.listing_checkpoint(), before.1); + assert_eq!( + snapshot.checkpoint(), + history(&r).await.checkpoint().unwrap() + ); + let encoded = radroots_protocol::terms::EncodedTerms::capture(snapshot.terms()).unwrap(); + assert_eq!(snapshot.terms_digest(), encoded.digest()); + assert_eq!(snapshot.terms().lines().len(), 1); + let fixture = data(); + let original = fixture["sources"] + .as_array() + .unwrap() + .iter() + .find(|row| row["name"] == "request") + .unwrap(); + let rumor: serde_json::Value = + serde_json::from_str(original["raw_rumor"].as_str().unwrap()).unwrap(); + let original = + radroots_protocol::commerce::decode(rumor["content"].as_str().unwrap().as_bytes()).unwrap(); + let radroots_domain::CommercePayload::Request(original) = original.content().payload() else { + panic!() + }; + assert_eq!(snapshot.terms(), original.terms()); + assert_eq!( + format!("{snapshot:?}"), + "StockRequestSnapshot(<private request>)" + ); + let mut raw = database(&r).await; + for statement in [ + "SELECT count(*) FROM stock_operations", + "SELECT count(*) FROM stock_movements", + "SELECT count(*) FROM stock_orders", + "SELECT count(*) FROM stock_pools", + ] { + let count: i64 = sqlx::query_scalar(statement) + .fetch_one(&mut raw) + .await + .unwrap(); + assert_eq!(count, 0); + } + raw.close().await.unwrap(); + assert_eq!(minima(&r).await, before); + r.store.close().await.unwrap(); + r.store = NativeWorkspace::open_seller_stock( + &r.path, + r.enrollment.input().clone(), + r.fixture.crypto(), + r.clock.clone(), + ) + .await + .unwrap(); + let recovered = inspect(&r, "request").await.unwrap(); + assert_eq!(recovered.terms(), snapshot.terms()); + assert_eq!(recovered.checkpoint(), snapshot.checkpoint()); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn historical_existence_without_quote_cannot_bypass_paused_unsupported_or_future_observed_heads() + { + for name in [ + "listing_paused", + "listing_withdrawn", + "listing_unsupported", + "listing_future", + ] { + let r = Rig::new().await; + seed(&r, "request_no_quote", false).await; + assert!( + inspect(&r, "request_no_quote") + .await + .unwrap() + .quote() + .is_none() + ); + r.retain(&r.capture(name)).await; + assert_eq!( + inspect(&r, "request_no_quote").await.unwrap_err().code(), + "stale_state", + "{name}" + ); + assert_eq!( + history(&r).await.analysis().readiness(), + CausalReadiness::Complete + ); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn still_valid_exact_explicit_quote_permits_its_historical_snapshot_without_public_offer_fallback() + { + for name in ["listing_paused", "listing_unsupported", "listing_future"] { + let r = Rig::new().await; + base(&r).await; + r.retain(&r.capture(name)).await; + let snapshot = inspect(&r, "request").await.unwrap(); + assert_eq!(snapshot.quote(), Some(identity("quote"))); + assert_eq!( + snapshot.terms().lines()[0].source().event_id().into_bytes(), + identity("listing_id").into_bytes() + ); + let old = r + .store + .stock_listing_source( + r.binding.clone(), + r.minimum().await, + r.capture("listing_fixed").listing_revision(), + r.enrollment.proof(), + ) + .await + .unwrap() + .unwrap(); + assert!(!old.is_current_observed()); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn authenticated_but_different_snapshots_quotes_withdrawals_and_forks_do_not_become_ready() { + for (name, quote, expected) in [ + ("request_wrong_snapshot", false, "invalid_evidence"), + ("request_wrong_quote_terms", true, "invalid_evidence"), + ] { + let r = Rig::new().await; + seed(&r, name, quote).await; + assert_eq!(inspect(&r, name).await.unwrap_err().code(), expected); + r.store.close().await.unwrap(); + } + for name in ["withdrawal", "decline", "future_commerce", "buyer_fork"] { + let r = Rig::new().await; + base(&r).await; + if name == "buyer_fork" { + retain(&r, "withdrawal").await; + } + retain(&r, name).await; + let expected = if name == "future_commerce" { + "capability_unavailable" + } else { + "stale_state" + }; + assert_eq!(inspect(&r, "request").await.unwrap_err().code(), expected); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn request_deadline_and_current_access_are_rechecked_after_all_actual_provider_io() { + for at in [160, 240, 300] { + let mut r = Rig::new().await; + base(&r).await; + let provider = reopen(&mut r).await; + let (private, public) = minima(&r).await; + provider.gate.arm( + Direction::Unwrap, + "radroots.seller_stock.public_source_part.v1", + 1, + ); + let mut future = Box::pin(r.store.stock_order_request( + r.binding.clone(), + private, + public, + identity("request"), + r.enrollment.proof(), + )); + assert!(futures::poll!(future.as_mut()).is_pending()); + provider.gate.entered(); + r.clock.0.store(at, Ordering::SeqCst); + provider.gate.release(); + let result = future.await; + match at { + 160 => assert_eq!(result.unwrap().observed_at().get(), 160), + 240 => assert_eq!(result.unwrap_err().code(), "deadline_exceeded"), + _ => assert_eq!(result.unwrap_err().code(), "grant_expired"), + } + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn protected_current_head_changes_after_opening_refuse_even_a_valid_quote_snapshot() { + let mut r = Rig::new().await; + base(&r).await; + let provider = reopen(&mut r).await; + let (private, public) = minima(&r).await; + let mut raw = database(&r).await; + provider.gate.arm( + Direction::Unwrap, + "radroots.seller_stock.public_source_head.v1", + 0, + ); + let mut future = Box::pin(r.store.stock_order_request( + r.binding.clone(), + private, + public, + identity("request"), + r.enrollment.proof(), + )); + assert!(futures::poll!(future.as_mut()).is_pending()); + provider.gate.entered(); + sqlx::query("UPDATE stock_public_heads SET protected=randomblob(length(protected))") + .execute(&mut raw) + .await + .unwrap(); + provider.gate.release(); + assert_eq!(future.await.unwrap_err().code(), "recovery_required"); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); +} diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/test_provider.rs b/crates/storage_sqlite/src/workspace/stock/public_source/test_provider.rs @@ -157,7 +157,7 @@ async fn public_source_close_drains_admitted_work_after_observer_loss() { let minimum = r.minimum().await; provider .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v8", 0); + .arm(Direction::Wrap, "radroots.seller_stock.authority.v9", 0); let mut future = Box::pin(r.store.retain_stock_listing( r.binding.clone(), minimum, @@ -213,7 +213,7 @@ async fn public_source_writes_recheck_expiry_and_head_rows_after_actual_protecti let mut raw = database(&r).await; provider .gate - .arm(Direction::Wrap, "radroots.seller_stock.authority.v8", 0); + .arm(Direction::Wrap, "radroots.seller_stock.authority.v9", 0); let mut future = Box::pin(r.store.retain_stock_listing( r.binding.clone(), minimum, diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/transaction.rs b/crates/storage_sqlite/src/workspace/stock/public_source/transaction.rs @@ -31,7 +31,7 @@ async fn access( } let (authority, record, root, grant) = super::super::read(turn.connection, binding.input(), turn.crypto).await?; - if authority.catalog != 8 || authority.public_sources.is_none() { + if !matches!(authority.catalog, 8 | 9) || authority.public_sources.is_none() { return Err(OperationError::UnsupportedOperation); } let current = record.authenticate(binding.input(), proof, turn.clock.now()?)?; @@ -282,7 +282,7 @@ pub(in crate::workspace) async fn retain( }); let root = turn .crypto - .seal_stock_root(turn.selected, 8, &next.encode()?) + .seal_stock_root(turn.selected, next.catalog, &next.encode()?) .await?; turn.namespace.validate()?; let mut tx = turn diff --git a/crates/storage_sqlite/src/workspace/stock/schema.rs b/crates/storage_sqlite/src/workspace/stock/schema.rs @@ -1,7 +1,7 @@ //! Exact stock catalogs. Enrollment-only version1 is retained without upgrade. use super::WorkspaceError; use sqlx::SqliteConnection; -pub(super) const CURRENT: i64 = 8; +pub(super) const CURRENT: i64 = 9; const AUTHORITY: &str = "CREATE TABLE stock_authority (singleton INTEGER PRIMARY KEY CHECK(singleton=1), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT"; const GRANTS: &str = "CREATE TABLE stock_grants (grant_id BLOB PRIMARY KEY CHECK(length(grant_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"; const POOLS: &str = "CREATE TABLE stock_pools (pool_id BLOB PRIMARY KEY CHECK(length(pool_id)=32), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID"; @@ -23,7 +23,7 @@ pub(super) fn objects( ]; match version { 1 => {} - 2..=8 => objects.extend([ + 2..=9 => objects.extend([ ("table", "stock_pools", "stock_pools", POOLS), ( "table", @@ -70,7 +70,7 @@ pub(super) fn objects( if version >= 5 { objects.push(("table","stock_mappings","stock_mappings","CREATE TABLE stock_mappings (listing_author BLOB NOT NULL CHECK(length(listing_author)=32), listing_d BLOB NOT NULL CHECK(length(listing_d)=16), option_id BLOB NOT NULL CHECK(length(option_id)=32), pool_id BLOB NOT NULL REFERENCES stock_pools(pool_id), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(listing_author,listing_d,option_id)) STRICT, WITHOUT ROWID")); } - if (6..=8).contains(&version) { + if (6..=9).contains(&version) { objects.push(("table","stock_source_records","stock_source_records","CREATE TABLE stock_source_records (record_id BLOB PRIMARY KEY CHECK(length(record_id)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); objects.push(("table","stock_source_evidence","stock_source_evidence","CREATE TABLE stock_source_evidence (envelope_id BLOB PRIMARY KEY CHECK(length(envelope_id)=32), record_id BLOB REFERENCES stock_source_records(record_id), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); objects.push(("index","stock_source_transaction_identity","stock_source_evidence","CREATE UNIQUE INDEX stock_source_transaction_identity ON stock_source_evidence(transaction_id)")); @@ -94,7 +94,7 @@ pub(super) fn objects( objects.push(("index","stock_order_operation_position","stock_operations","CREATE INDEX stock_order_operation_position ON stock_operations(order_id,revision) WHERE order_id IS NOT NULL")); objects.push(("table","stock_orders","stock_orders","CREATE TABLE stock_orders (order_id BLOB PRIMARY KEY CHECK(length(order_id)=32), revision INTEGER NOT NULL CHECK(revision>0), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); } - if version == 8 { + if matches!(version, 8 | 9) { objects.push(("table","stock_public_events","stock_public_events","CREATE TABLE stock_public_events (event_id BLOB PRIMARY KEY CHECK(length(event_id)=32), listing_author BLOB NOT NULL CHECK(length(listing_author)=32), listing_d BLOB NOT NULL CHECK(length(listing_d)=16), created_at BLOB NOT NULL CHECK(length(created_at)=8), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), revision INTEGER NOT NULL CHECK(revision>0), chain_head BLOB NOT NULL CHECK(length(chain_head)=32), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144)) STRICT, WITHOUT ROWID")); objects.push(("index","stock_public_transaction_identity","stock_public_events","CREATE UNIQUE INDEX stock_public_transaction_identity ON stock_public_events(transaction_id)")); objects.push(( diff --git a/crates/storage_sqlite/src/workspace/stock/source.rs b/crates/storage_sqlite/src/workspace/stock/source.rs @@ -8,12 +8,15 @@ use radroots_storage::{ }; use sha2::{Digest, Sha256}; use zeroize::Zeroizing; -mod checkpoint; -mod history; +pub(in crate::workspace::stock) mod checkpoint; +pub(in crate::workspace::stock) mod history; +pub(in crate::workspace::stock) mod request; pub use history::StockHistorySnapshot; +pub use request::StockRequestSnapshot; mod record; mod transaction; pub(in crate::workspace) use transaction::history as query_history; +pub(in crate::workspace) use transaction::inspect_request; pub(in crate::workspace) use transaction::{query, retain}; /// Authenticated carrier/profile disposition, without causal actionability. @@ -250,6 +253,22 @@ impl std::fmt::Debug for StockSourceSnapshot { } } impl NativeWorkspace { + /// Inspects original initial request, quote, source snapshots and deadlines + /// under current administrative read access. This acquires no execution + /// permission, pending order fence, signature or physical stock hold. + pub async fn stock_order_request( + &self, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + listing_minimum: radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + request: RecordId, + proof: &AttachmentProof, + ) -> Result<StockRequestSnapshot, OperationError> { + let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; + self.worker + .stock_order_request(binding, minimum, listing_minimum, request, proof) + .await + } /// Reads complete retained local causal coverage for one bilateral scope. /// Current administrator access is required. This neither authorizes a new /// request nor reports an installed agreement, global history or stock hold. diff --git a/crates/storage_sqlite/src/workspace/stock/source/checkpoint.rs b/crates/storage_sqlite/src/workspace/stock/source/checkpoint.rs @@ -1,6 +1,6 @@ use super::*; use sqlx::Row; -pub(super) enum Target { +pub(in crate::workspace::stock) enum Target { Minimum(StockSourceCheckpointRef), Envelope( EnvelopeEventId, @@ -8,7 +8,7 @@ pub(super) enum Target { ), Record(RecordId, Option<[u8; 32]>), } -pub(super) struct Proof { +pub(in crate::workspace::stock) struct Proof { lower: u64, upper: u64, digest: [u8; 32], @@ -83,7 +83,7 @@ impl Proof { Ok(()) } } -pub(super) async fn authenticate( +pub(in crate::workspace::stock) async fn authenticate( connection: &mut SqliteConnection, input: &AttachmentInput, crypto: &WorkspaceCrypto, diff --git a/crates/storage_sqlite/src/workspace/stock/source/history.rs b/crates/storage_sqlite/src/workspace/stock/source/history.rs @@ -19,8 +19,14 @@ pub struct StockHistorySnapshot { pub(super) listings: StockListingCheckpointRef, pub(super) observed_at: UnixSeconds, pub(super) records: usize, + pub(super) checkpoint: Option<radroots_domain::CheckpointRef>, } impl StockHistorySnapshot { + /// Borrows complete local causal coverage data. This is not an installed + /// order, pending-decision fence or permission to accept the request. + pub fn checkpoint(&self) -> Option<&radroots_domain::CheckpointRef> { + self.checkpoint.as_ref() + } /// Returns the exact selected participant/thread/order scope. pub const fn scope(&self) -> CausalScope { self.scope @@ -52,9 +58,12 @@ impl std::fmt::Debug for StockHistorySnapshot { f.write_str("StockHistorySnapshot(<private coverage>)") } } -pub(super) struct Prepared { +pub(in crate::workspace::stock) struct Prepared { pub records: BTreeMap<RecordId, DecodedRecord>, pub analysis: CausalAnalysis, + pub checkpoint: Option<radroots_domain::CheckpointRef>, + pub external: Vec<SourceId>, + pub uninterpreted: Vec<SourceId>, ancestry: checkpoint::Proof, public: super::super::public_source::history::Witness, revision: u64, @@ -181,7 +190,7 @@ async fn original_rumor( } Ok(rumor) } -pub(super) async fn prepare( +pub(in crate::workspace::stock) async fn prepare( connection: &mut SqliteConnection, input: &AttachmentInput, crypto: &WorkspaceCrypto, @@ -286,20 +295,30 @@ pub(super) async fn prepare( .iter() .map(|(id, record)| CausalRecord::new(*id, record.content())) .collect(); - let analysis = causal::analyze( + let external: Vec<_> = external.into_iter().collect(); + let uninterpreted: Vec<_> = uninterpreted.into_iter().collect(); + let coverage = radroots_protocol::commerce::CapturedCausalCoverage::capture( scope, &nodes, - &external.into_iter().collect::<Vec<_>>(), - &uninterpreted.into_iter().collect::<Vec<_>>(), + &external, + &uninterpreted, ) .map_err(|error| match error { - causal::CausalError::LimitExceeded => OperationError::Workspace(WorkspaceError::Capacity), - causal::CausalError::InvalidScope => OperationError::InvalidEvidence, + radroots_protocol::commerce::RecordWireError::LimitExceeded => { + OperationError::Workspace(WorkspaceError::Capacity) + } + radroots_protocol::commerce::RecordWireError::InvalidInput => { + OperationError::InvalidEvidence + } _ => OperationError::RecoveryRequired, })?; + let (analysis, checkpoint) = coverage.into_parts(); Ok(Prepared { records, analysis, + checkpoint, + external, + uninterpreted, ancestry, public, revision, @@ -308,7 +327,7 @@ pub(super) async fn prepare( }) } impl Prepared { - pub(super) async fn confirm( + pub(in crate::workspace::stock) async fn confirm( &self, connection: &mut SqliteConnection, ) -> Result<(), OperationError> { diff --git a/crates/storage_sqlite/src/workspace/stock/source/request.rs b/crates/storage_sqlite/src/workspace/stock/source/request.rs @@ -0,0 +1,215 @@ +//! Fresh initial request/source inspection. Execution rights, installed order +//! state, pending fences and actual atomic stock effects remain separate. +use super::*; +use radroots_domain::{ + CheckpointRef, Terms, TermsDigest, UnixSeconds, + causal::{CausalRecord, CausalScope, RequestClaimError}, +}; +use radroots_storage::workspace::seller_stock::StockListingCheckpointRef; +use std::collections::BTreeMap; + +/// Explicit private request/source data under current administrative read access. +/// This does not authorize execution or promise a physical hold/agreement. +pub struct StockRequestSnapshot { + pub(super) scope: CausalScope, + pub(super) request: RecordId, + pub(super) terms: Box<Terms>, + pub(super) digest: TermsDigest, + pub(super) expires: UnixSeconds, + pub(super) quote: Option<RecordId>, + pub(super) checkpoint: CheckpointRef, + pub(super) sources: StockSourceCheckpointRef, + pub(super) listings: StockListingCheckpointRef, + pub(super) observed_at: UnixSeconds, +} +impl StockRequestSnapshot { + /// Exact selected scope derived from original authenticated request content. + pub const fn scope(&self) -> CausalScope { + self.scope + } + /// Exact original request identity, distinct from its transport envelopes. + pub const fn request(&self) -> RecordId { + self.request + } + /// Explicit private disclosure of complete original buyer-authorized terms. + pub fn terms(&self) -> &Terms { + &self.terms + } + /// Canonical complete terms identity; no approval is minted by this getter. + pub const fn terms_digest(&self) -> TermsDigest { + self.digest + } + /// Earliest request/quote deadline, excluding grant/approval/issuance bounds. + pub const fn expires_at(&self) -> UnixSeconds { + self.expires + } + /// Exact optional complete seller quote used for source permission. + pub const fn quote(&self) -> Option<RecordId> { + self.quote + } + /// Complete local causal data; not an installed order or decision fence. + pub const fn checkpoint(&self) -> &CheckpointRef { + &self.checkpoint + } + /// Independently acknowledged retained private source progress. + pub const fn source_checkpoint(&self) -> StockSourceCheckpointRef { + self.sources + } + /// Independently acknowledged retained public source progress. + pub const fn listing_checkpoint(&self) -> StockListingCheckpointRef { + self.listings + } + /// Final usable observation after transaction witnesses/current access checks. + pub const fn observed_at(&self) -> UnixSeconds { + self.observed_at + } +} +impl std::fmt::Debug for StockRequestSnapshot { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("StockRequestSnapshot(<private request>)") + } +} +pub(in crate::workspace::stock) struct Prepared { + pub scope: CausalScope, + pub request: RecordId, + pub digest: TermsDigest, + pub expires: UnixSeconds, + pub quote: Option<RecordId>, + pub history: history::Prepared, + lookup: checkpoint::Proof, + views: BTreeMap<EnvelopeEventId, super::super::public_source::admission::ListingView>, +} +fn claim_error(error: RequestClaimError) -> OperationError { + match error { + RequestClaimError::MissingHistory => OperationError::MissingHistory, + RequestClaimError::Uninterpreted => OperationError::UnsupportedOperation, + RequestClaimError::Expired => OperationError::DeadlineExceeded, + RequestClaimError::ClockAhead => WorkspaceError::Unavailable.into(), + RequestClaimError::Conflicted + | RequestClaimError::Withdrawn + | RequestClaimError::Declined + | RequestClaimError::ConflictingAuthorizations + | RequestClaimError::RequiresReconciliation => OperationError::StaleState, + _ => OperationError::InvalidEvidence, + } +} +impl Prepared { + pub fn terms(&self) -> Result<&Terms, OperationError> { + match self + .history + .records + .get(&self.request) + .map(|record| record.content().payload()) + { + Some(radroots_domain::CommercePayload::Request(request)) => Ok(request.terms()), + _ => Err(OperationError::RecoveryRequired), + } + } + pub fn validate_at(&self, at: UnixSeconds) -> Result<(), OperationError> { + if at >= self.expires { + return Err(OperationError::DeadlineExceeded); + } + for line in self.terms()?.lines() { + self.views + .get(&line.source().event_id()) + .ok_or(OperationError::RecoveryRequired)? + .validate(line, self.quote.is_some(), at)?; + } + Ok(()) + } + pub async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> { + self.lookup.confirm(connection).await?; + self.history.confirm(connection).await?; + for view in self.views.values() { + view.confirm(connection).await?; + } + Ok(()) + } +} +pub(in crate::workspace::stock) async fn prepare( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + authority: &Authority, + request: RecordId, + listing_minimum: StockListingCheckpointRef, + observed_at: UnixSeconds, +) -> Result<Prepared, OperationError> { + let raw = record::canonical(connection, input, crypto, request).await?; + let observed = raw + .as_ref() + .map(|(raw, _)| <[u8; 32]>::from(Sha256::digest(&**raw))); + let lookup = checkpoint::authenticate( + connection, + input, + crypto, + authority + .sources + .ok_or(OperationError::UnsupportedOperation)?, + checkpoint::Target::Record(request, observed), + ) + .await?; + let (raw, _) = raw.ok_or(OperationError::MissingHistory)?; + let decoded = + radroots_protocol::commerce::decode(&raw).map_err(|_| OperationError::RecoveryRequired)?; + let header = decoded.content().header(); + if decoded.content().record_type() != radroots_domain::CommerceType::Request { + return Err(OperationError::InvalidCommand); + } + let scope = CausalScope::new( + header.thread_id(), + header.order_id().ok_or(OperationError::InvalidEvidence)?, + header.buyer(), + header.seller(), + ) + .map_err(|_| OperationError::InvalidEvidence)?; + let history = + history::prepare(connection, input, crypto, authority, scope, listing_minimum).await?; + let nodes: Vec<_> = history + .records + .iter() + .map(|(id, record)| CausalRecord::new(*id, record.content())) + .collect(); + let claim = radroots_domain::causal::prepare_initial_request( + scope, + request, + &nodes, + &history.external, + &history.uninterpreted, + observed_at, + ) + .map_err(claim_error)?; + let digest = radroots_protocol::terms::EncodedTerms::capture(claim.terms()) + .map_err(|_| OperationError::InvalidEvidence)? + .digest(); + let expires = claim.expires_at(); + let quote = claim.quote(); + let mut views = BTreeMap::new(); + for line in claim.terms().lines() { + if let std::collections::btree_map::Entry::Vacant(entry) = + views.entry(line.source().event_id()) + { + let view = super::super::public_source::admission::prepare( + connection, + input, + crypto, + authority, + line.source(), + observed_at, + ) + .await?; + entry.insert(view); + } + views[&line.source().event_id()].validate(line, claim.quote().is_some(), observed_at)?; + } + Ok(Prepared { + scope, + request, + digest, + expires, + quote, + history, + lookup, + views, + }) +} diff --git a/crates/storage_sqlite/src/workspace/stock/source/transaction.rs b/crates/storage_sqlite/src/workspace/stock/source/transaction.rs @@ -28,7 +28,7 @@ async fn access( } let (authority, record, root, grant) = super::super::read(turn.connection, binding.input(), turn.crypto).await?; - if !(6..=8).contains(&authority.catalog) { + if !(6..=9).contains(&authority.catalog) { return Err(OperationError::UnsupportedOperation); } let current = record.authenticate(binding.input(), proof, turn.clock.now()?)?; @@ -113,7 +113,7 @@ pub(in crate::workspace) async fn history( proof: AttachmentProof, ) -> Result<StockHistorySnapshot, OperationError> { let access = access(turn, &binding, minimum, &proof).await?; - if access.authority.catalog != 8 { + if !matches!(access.authority.catalog, 8 | 9) { return Err(OperationError::UnsupportedOperation); } let prepared = super::history::prepare( @@ -154,7 +154,72 @@ pub(in crate::workspace) async fn history( .public_sources .ok_or(OperationError::RecoveryRequired)?; Ok(StockHistorySnapshot { - scope,records:prepared.records.len(),analysis:prepared.analysis,observed_at, + scope,records:prepared.records.len(),analysis:prepared.analysis,checkpoint:prepared.checkpoint,observed_at, + sources:StockSourceCheckpointRef::from_host_metadata(turn.selected.authority(),private.revision,private.head)?.with_optional_authorization(access.authority.authorization), + listings:radroots_storage::workspace::seller_stock::StockListingCheckpointRef::from_host_metadata(turn.selected.authority(),public.revision,public.head)?.with_optional_authorization(access.authority.authorization), + }) +} +pub(in crate::workspace) async fn inspect_request( + turn: &mut Turn<'_>, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + listing_minimum: radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + selected: RecordId, + proof: AttachmentProof, +) -> Result<StockRequestSnapshot, OperationError> { + let access = access(turn, &binding, minimum, &proof).await?; + if !matches!(access.authority.catalog, 8 | 9) { + return Err(OperationError::UnsupportedOperation); + } + let prepared = super::request::prepare( + turn.connection, + turn.selected, + turn.crypto, + &access.authority, + selected, + listing_minimum, + access.current.observed_at(), + ) + .await; + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<_, OperationError> = async { + let witnessed = match &prepared { + Ok(value) => value.confirm(&mut tx).await, + Err(_) => Ok(()), + }; + // Do not disclose even a detailed source denial under expired/revoked + // access. All provider work and row witnesses precede this final check. + let current = access + .confirm(&mut tx, turn.namespace, turn.clock, &proof) + .await?; + witnessed?; + if let Ok(value) = &prepared { + value.validate_at(current.observed_at())?; + } + Ok(current.observed_at()) + } + .await; + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + let observed_at = checked?; + let prepared = prepared?; + let private = access + .authority + .sources + .ok_or(OperationError::RecoveryRequired)?; + let public = access + .authority + .public_sources + .ok_or(OperationError::RecoveryRequired)?; + Ok(StockRequestSnapshot { + scope:prepared.scope,request:prepared.request,terms:Box::new(prepared.terms()?.clone()),digest:prepared.digest, + expires:prepared.expires,quote:prepared.quote,checkpoint:prepared.history.checkpoint.clone().ok_or(OperationError::RecoveryRequired)?,observed_at, sources:StockSourceCheckpointRef::from_host_metadata(turn.selected.authority(),private.revision,private.head)?.with_optional_authorization(access.authority.authorization), listings:radroots_storage::workspace::seller_stock::StockListingCheckpointRef::from_host_metadata(turn.selected.authority(),public.revision,public.head)?.with_optional_authorization(access.authority.authorization), }) diff --git a/crates/storage_sqlite/src/workspace/stock/tests.rs b/crates/storage_sqlite/src/workspace/stock/tests.rs @@ -109,7 +109,7 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang ) .await .unwrap(); - assert_eq!(schema::admit(&mut connection).await, Ok(8)); + assert_eq!(schema::admit(&mut connection).await, Ok(9)); assert_eq!(schema::integrity(&mut connection).await, Ok(())); let root: Vec<u8> = sqlx::query_scalar("SELECT protected FROM stock_authority") .fetch_one(&mut connection) @@ -117,18 +117,18 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang .unwrap(); let clear = fixture .crypto() - .open_stock_root(enrollment.input(), 8, &root) + .open_stock_root(enrollment.input(), 9, &root) .await .unwrap(); let authority = clear - .expose_secret(|bytes| Authority::decode(bytes, 8)) + .expose_secret(|bytes| Authority::decode(bytes, 9)) .unwrap(); clear.expose_secret(|bytes| { let original:serde_json::Value=serde_json::from_slice(bytes).unwrap(); assert_eq!(original["inventory"]["mappings"],"0"); for bad in [serde_json::json!([]),serde_json::json!({"revision":"1","pools":"1","movements":"1","head":original["inventory"]["head"]})] { let mut value=original.clone();value["inventory"]=bad; - assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),8).is_err()); + assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),9).is_err()); } for bad in [ serde_json::json!([]), @@ -139,7 +139,7 @@ async fn current_grant_set_reopens_with_original_namespace_after_one_grant_chang serde_json::json!({"revision":"1","records":"2","parts":"3","head":"01".repeat(32)}), ] { let mut value=original.clone();value["sources"]=bad; - assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),8).is_err()); + assert!(Authority::decode(&serde_json::to_vec(&value).unwrap(),9).is_err()); } }); assert_eq!(authority.input, *enrollment.input()); @@ -189,7 +189,7 @@ async fn current_and_retained_roots_bind_the_complete_namespace_with_distinct_ca let caller = namespace.attachment(GrantId::from_bytes([9; 32])).unwrap(); let crypto = fixture.crypto(); let clear = b"synthetic context payload"; - for version in [4, 5, 6, 7, 8] { + for version in [4, 5, 6, 7, 8, 9] { let current = crypto .seal_stock_root(&owner, version, clear) .await @@ -264,10 +264,14 @@ async fn retained_inventory_v7_keeps_consent_ledger_without_public_source_tables retained_inventory_catalog(7).await; } #[tokio::test] -async fn current_v8_preserves_physical_and_private_source_progress_with_public_sources() { - assert_eq!(schema::CURRENT, 8); +async fn retained_v8_preserves_physical_and_private_source_progress_with_public_sources() { retained_inventory_catalog(8).await; } +#[tokio::test] +async fn current_v9_preserves_prior_families_and_adds_acceptance_admission() { + assert_eq!(schema::CURRENT, 9); + retained_inventory_catalog(9).await; +} // Exact catalog fixtures exercise retained/successor codecs; they are not // evidence from a predecessor executable or a factory migration. pub(super) async fn literal_catalog( @@ -328,7 +332,7 @@ pub(super) async fn literal_catalog( if catalog >= 7 { value["inventory"]["orders"] = serde_json::json!("0"); } - if catalog == 8 { + if matches!(catalog, 8 | 9) { value["public_sources"] = serde_json::json!({"revision":"0","events":"0","heads":"0","parts":"0","head":null}); } @@ -369,6 +373,7 @@ pub(super) async fn literal_catalog( 6 => "PRAGMA user_version=6", 7 => "PRAGMA user_version=7", 8 => "PRAGMA user_version=8", + 9 => "PRAGMA user_version=9", _ => unreachable!(), }) .execute(&mut *tx) @@ -392,7 +397,10 @@ async fn retained_inventory_catalog(catalog: i64) { let binding = store.authenticate(input.clone(), &proof).await.unwrap(); let authority = store.stock_authority(input.clone(), &proof).await.unwrap(); assert_eq!(authority.source_checkpoint().is_some(), catalog >= 6); - assert_eq!(authority.listing_checkpoint().is_some(), catalog == 8); + assert_eq!( + authority.listing_checkpoint().is_some(), + matches!(catalog, 8 | 9) + ); let minimum = authority.inventory_checkpoint().unwrap(); let context = CommandContextData::new( OperationId::from_bytes([7; 32]), @@ -634,7 +642,7 @@ async fn retained_inventory_catalog(catalog: i64) { .fetch_one(&mut connection) .await .unwrap(); - let old = if matches!(catalog, 7 | 8) { + let old = if matches!(catalog, 7..=9) { let retained = ledger::read( &mut connection, &input, @@ -687,7 +695,7 @@ async fn retained_inventory_catalog(catalog: i64) { // inside a real SQL transaction. Row counts and the protected header // stay unchanged while one referenced ciphertext changes. for part in [false, true] { - if part && !matches!(catalog, 7 | 8) { + if part && !matches!(catalog, 7..=9) { continue; } let (authority, _, _, _) = read(&mut connection, &input, &fixture.crypto()) @@ -758,6 +766,7 @@ async fn retained_inventory_catalog(catalog: i64) { 6 => "PRAGMA user_version=7", 7 => "PRAGMA user_version=6", 8 => "PRAGMA user_version=7", + 9 => "PRAGMA user_version=8", _ => unreachable!(), }) .execute(&mut connection) diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -38,6 +38,19 @@ const QUEUE_MAX_BYTES: usize = 4 * 1024 * 1024; const QUEUE_CAPACITY: usize = 32; type Reply<T, E = WorkspaceError> = oneshot::Sender<Result<T, E>>; enum Job { + PrepareStockAcceptance( + Box<stock::StockAcceptanceRequest>, + AttachmentProof, + Reply<stock::StockAcceptanceOutcome, OperationError>, + ), + StockOrderRequest( + Box<WorkspaceBinding>, + radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + radroots_domain::RecordId, + AttachmentProof, + Reply<stock::StockRequestSnapshot, OperationError>, + ), StockOrderHistory( Box<WorkspaceBinding>, radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, @@ -226,6 +239,12 @@ enum Job { impl Job { fn reject_recovery(self) { match self { + Self::PrepareStockAcceptance(_, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } + Self::StockOrderRequest(_, _, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } Self::StockOrderHistory(_, _, _, _, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } @@ -467,6 +486,8 @@ impl Handle { | Job::RetainStockSource(..) | Job::StockSource(..) | Job::StockOrderHistory(..) + | Job::StockOrderRequest(..) + | Job::PrepareStockAcceptance(..) | Job::Revoke(..) | Job::StockAuthority(..) ) @@ -683,6 +704,56 @@ impl Handle { }; let _ = reply.send(result); } + Job::PrepareStockAcceptance(request, proof, reply) => { + let result = if kind == Kind::SellerStock { + stock::inventory::acceptance::admit( + &mut stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + }, + *request, + proof, + ) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } + Job::StockOrderRequest( + binding, + minimum, + listings, + selected, + proof, + reply, + ) => { + let result = if kind == Kind::SellerStock { + stock::source::inspect_request( + &mut stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + }, + *binding, + minimum, + listings, + selected, + proof, + ) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } Job::StockOrderHistory( binding, minimum, @@ -1269,6 +1340,35 @@ impl Handle { ))?; result.await.unwrap_or(Ok(anchor)) } + pub(super) async fn prepare_stock_acceptance( + &self, + request: stock::StockAcceptanceRequest, + proof: AttachmentProof, + ) -> Result<stock::StockAcceptanceOutcome, OperationError> { + let unknown = stock::StockAcceptanceOutcome::Unknown(request.attempt()); + let (reply, result) = oneshot::channel(); + self.send(Job::PrepareStockAcceptance(Box::new(request), proof, reply))?; + result.await.unwrap_or(Ok(unknown)) + } + pub(super) async fn stock_order_request( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + listings: radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + selected: radroots_domain::RecordId, + proof: AttachmentProof, + ) -> Result<stock::StockRequestSnapshot, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::StockOrderRequest( + Box::new(binding), + minimum, + listings, + selected, + proof, + reply, + ))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } pub(super) async fn stock_order_history( &self, binding: WorkspaceBinding, @@ -1336,7 +1436,7 @@ impl Handle { fn send(&self, job: Job) -> Result<(), WorkspaceError> { let bytes = match &job { Job::RetainStockListing(..) => 256 * 1024, - Job::IssueStockConsent(..) => 512 * 1024, + Job::IssueStockConsent(..) | Job::PrepareStockAcceptance(..) => 512 * 1024, Job::RetainStockSource(..) => 256 * 1024, Job::ChangeStockGrant(..) | Job::ExecuteInventory(..) => 64 * 1024, Job::CaptureDeliveryObservation(..) => 96 * 1024, diff --git a/crates/storage_sqlite/tests/fixtures/stock_history.v1.json b/crates/storage_sqlite/tests/fixtures/stock_history.v1.json @@ -18,7 +18,7 @@ "library": "nostr-tools@2.23.5", "curve": "@noble/curves@2.0.1", "bip340_primary_vector_zero_matched": true, - "script_sha256": "e0fbe3ee194f8e27cdcb1011d16fe48020536d56bd2a5ced11dcf69d1d8c1592", + "script_sha256": "1b2355a969029b9f5b65527826b83b1df6f74649e9a9792a4685370ad0e26215", "package_lock_sha256": "bd23a2b631ddd90c91ce044187e4feaaf27fb1f4590da2e203afc28d8ea6cd22", "redistribution_provenance_sha256": "145d2cb14377bf67c0e65c452ed07ba10577a1e8ea1db3979d2d2780cb31a7a6", "record_template_path": "crates/protocol/tests/fixtures/commerce_wire.v1.json", @@ -127,6 +127,69 @@ "raw_rumor": "{\"id\":\"152b30643b4a90996d3c0817b9cd0ed31cb1c3ee2b8cd59a040414b285c6049a\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":102,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"private_future\\\":\\\"Unknown authenticated statement\\\",\\\"profile\\\":\\\"radroots.commerce\\\",\\\"type\\\":\\\"future_record\\\",\\\"version\\\":2}\"}", "rumor_id": "152b30643b4a90996d3c0817b9cd0ed31cb1c3ee2b8cd59a040414b285c6049a", "record_id": null + }, + { + "name": "request_no_quote", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"d56294b5a9d1f8cccfaa4d0b52f8c970dcae64e8215cf4782bae1dfacfe4f968\",\"pubkey\":\"3a597c9ff165369e5d90d1913dc2aefea0957936717f1ec39ea20698d08939f9\",\"created_at\":1699993988,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"8fe566e1fa91476af3393e39cc909daa80f22749a003558363a5a1711f1cdb17dd5169112e57efbc1988edd85da2b2e09f0485ca2229adae2286fdbcef93d427\"}", + "raw_seal": "{\"id\":\"2aef8b3773a2776e21c2c814f3574db73532c48e96dad077ed429ad24e187bb0\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994989,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"80781bca39bf85cf3c5d42faaa3a03b9a55575b55ecfb821efca3ac29a8b2ced9a70fed7bb669830236f8b2116f3a4ad8e2e25adb42ede395cded2592e748240\"}", + "raw_rumor": "{\"id\":\"b7739c823abf11e0e03986ca7d530b4d9bdb215bc9b581bb6b15d54d8b12b978\",\"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\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":null,\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬\\\",\\\"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 🥕\\\",\\\"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\\\":\\\"e539f4a846948aea057cdc3cf0df804232e7a519dcfef808bd049c13e382cd27\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "b7739c823abf11e0e03986ca7d530b4d9bdb215bc9b581bb6b15d54d8b12b978", + "record_id": "e539f4a846948aea057cdc3cf0df804232e7a519dcfef808bd049c13e382cd27" + }, + { + "name": "request_wrong_snapshot", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"e66be9ec678b591e6fc5ba03bde1b52600f1f31632f93d1a396a03bec1eabee7\",\"pubkey\":\"d253343f4b4a8ff42a80594f80175a9138e9c508bf6e3d655b2458b3513bc3d0\",\"created_at\":1699993987,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"57b1c4c169cfd66a2bece018680e1e65482b2c4f34efcd5b1b84161d04bb37d9d80614b1ef38c2c78dbf79dd09aa3e9bbce994246726dfb4e577a45afb033846\"}", + "raw_seal": "{\"id\":\"4095da47150240f52e8925c3e037dbf2475e377f21f8012694d0b6b8e2df413b\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994988,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"6aaf63dce89a07b05e307ddddbe0993a6bfea8fd480537838d9cd70456a1c35eefc84601a2aeca38b06915e0157434ab528a3ef6940b720fc86c719297576b97\"}", + "raw_rumor": "{\"id\":\"10a744841d44d4413af10d298650467f1ec55cf55ed60f32916f5f9d3710f234\",\"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\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":null,\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬\\\",\\\"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\\\":\\\"Changed copied option snapshot\\\",\\\"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 🥕\\\",\\\"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\\\":\\\"da2fb66f0becfdc75ccea1b2e88e2b785e60f8d8701d45d18a976ac645c65b91\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "10a744841d44d4413af10d298650467f1ec55cf55ed60f32916f5f9d3710f234", + "record_id": "da2fb66f0becfdc75ccea1b2e88e2b785e60f8d8701d45d18a976ac645c65b91" + }, + { + "name": "request_wrong_quote_terms", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"8f37bcced755662bfaad0282f9d059023627e45dc573052bac406007f0414cd8\",\"pubkey\":\"0cbe3205096f10ff5de9c86155290393b9ceec90bbac68ac5054facb950ca15e\",\"created_at\":1699993986,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"ce159ba5a2db6a1f3179d08b42984a89a8abc6f24bd580c3046b25fab95506ee6ba1b69bafcfa87a0d668860c454ab40ac1882329bd73f93bec83205f25ca623\"}", + "raw_seal": "{\"id\":\"cbe04c49892b0e13b5f4bd0b67a72f4cb86b52e62bc3ac5bf28c76900f0d66cf\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994987,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"b11d7c00790cb718ddc35b0f63ddbd273f401839f351bb038242bdb51cff6ea3fb3dfd458b9f79b0e7cf5e5f1bf4c2981d909f3bc179d6a2faf487b37203f0e2\"}", + "raw_rumor": "{\"id\":\"a26db2ed2671b8cddfa13e6f3cdeed2ec2bde5513edcebfe80dc29282f52e099\",\"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🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬 Changed exact quote terms.\\\",\\\"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 🥕\\\",\\\"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\\\":\\\"40c30c113b944704d5c103ccffd4814c285c78c48faf8f6d238efb317b55e63a\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "a26db2ed2671b8cddfa13e6f3cdeed2ec2bde5513edcebfe80dc29282f52e099", + "record_id": "40c30c113b944704d5c103ccffd4814c285c78c48faf8f6d238efb317b55e63a" + }, + { + "name": "request_early_expiry", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"53687aba6801b45c835f2bc475666ae112ab295f5097e60baed9e3e4b787ad90\",\"pubkey\":\"a0422ec172017ecb871ae659027fbe318b6b9d810110cf2273098ef900600283\",\"created_at\":1699993985,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"5dd99efb4e591dd16046493d283469e21387b5323349551e05c55dd8f5050d8563f8b24b7a6af636b0155751125e21351860359e1296403532facf52a15e8fb5\"}", + "raw_seal": "{\"id\":\"13d2d58513d6943e67743e0054d4c854c271fcc9c147aecc442e50f541de5520\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994986,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"dcf507b24fe552c7fca1946e4701c37102f0267b0d8ed10247baa0577be47bfb358287da212b6bfe0eb8340483824efa4b93be8b76e303c95f513147949294a9\"}", + "raw_rumor": "{\"id\":\"c514698a0939b337139c147187ca4eaca73dc5236a122e410dc5758b85f3b280\",\"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\\\":\\\"151\\\",\\\"quote\\\":\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬\\\",\\\"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 🥕\\\",\\\"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\\\":\\\"780822705129bbb3f9ea2ce9e084907a89f7aaf7aa142c0130cfdb5cc8ed9953\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "c514698a0939b337139c147187ca4eaca73dc5236a122e410dc5758b85f3b280", + "record_id": "780822705129bbb3f9ea2ce9e084907a89f7aaf7aa142c0130cfdb5cc8ed9953" + }, + { + "name": "request_other_order", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"45a142ab85c4c186178f9d6ce82fe3cb03ff94c93697dbe9c2fdaa5edb1c9682\",\"pubkey\":\"4313c9cf08224e7018413b09e65447311cde71005ee60bd53a8db04156fed594\",\"created_at\":1699993984,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"a735b5dcad4c1f55f751cbd10f5681b7de4d005ca1752178ede690ac53d86b9428a761806c3ddb00a325a8e9921a7b285d3a29df6e20d873b665dcc0b5cc3649\"}", + "raw_seal": "{\"id\":\"4f6f4b02f7d3e398589b6ed3ac330db137e8618eb533da2b0565e4ce6a97a7b0\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994985,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"a58634b506234d0db30ba22412be3ea81d0733a7696318dc0c484bec36ebc7d2ad65ccbbbb58ffedfde765b08eab663ff1ac1360830d3f367bc452a864049135\"}", + "raw_rumor": "{\"id\":\"ca28b89f40ac3b8730030d98b4a04b1ac152090a8d56469f20a690217f72671a\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"101\\\",\\\"order_id\\\":\\\"7474747474747474747474747474747474747474747474747474747474747474\\\",\\\"parents\\\":[\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":null,\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬\\\",\\\"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 🥕\\\",\\\"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\\\":\\\"ec41ba6c08862fcd71517c1a54bc69a58fa8ab94c34ed14778969855c1e645df\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "ca28b89f40ac3b8730030d98b4a04b1ac152090a8d56469f20a690217f72671a", + "record_id": "ec41ba6c08862fcd71517c1a54bc69a58fa8ab94c34ed14778969855c1e645df" + }, + { + "name": "request_future_promise", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"3efd4d9650feab3eee4dc1df09181590068ec1c4e9b15f001606a5e33eabe899\",\"pubkey\":\"b8f2ef1824e63ff3f9946a5f611cc766c7799d3d7e7e3186eb35f02f7a6eac54\",\"created_at\":1699993983,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"e4d9551743f7ca5fc8c394071a3afa8647a55ae8e7b6e6779cefe6dfd855ffcb217e2dccc91244d4cb880aefbc95a35247ea1d31ea4b667ee4ec6113c45bb2d2\"}", + "raw_seal": "{\"id\":\"efccabde54c0ed929585279b3182e459c3f7eb2aeb2451304c4069f8bf82906f\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994984,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"48dd8accd9f23e3c6a509830772601715b28ee8c8a6fc2a6608bf47b3d9a5df646be874523dcee5bfb0aba7d85221580ded03488a52a127fa82280e5caec3e28\"}", + "raw_rumor": "{\"id\":\"9c069ef85a434f6087e956bb097e02a7340cdbed9edd6b0d33c2f36cf25eb43b\",\"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\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":null,\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬\\\",\\\"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 🥕\\\",\\\"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\\\":{\\\"expected_window\\\":{\\\"end\\\":\\\"400\\\",\\\"start\\\":\\\"300\\\",\\\"timezone\\\":\\\"Etc/UTC\\\"},\\\"risk_disclosure\\\":\\\"Weather and future supply may change.\\\",\\\"type\\\":\\\"future_promise\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"52b48cb02297f4b5d4a6440ec3d07bae7297943f0c8bcefe829068a65e734ec7\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "9c069ef85a434f6087e956bb097e02a7340cdbed9edd6b0d33c2f36cf25eb43b", + "record_id": "52b48cb02297f4b5d4a6440ec3d07bae7297943f0c8bcefe829068a65e734ec7" + }, + { + "name": "request_variable_weight", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"6f34bcb2b7e0bd55f6d0ab4546e3cc5a9e462a4bd5544ded5292278687828418\",\"pubkey\":\"cead2b51f8d8adec2d89651b2da5ffa51f5cbfab19fb76882bdf0faabf73c60e\",\"created_at\":1699993982,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"c10c9c5c3e4feb90fc2bccb0c614eed26d441d4438b5044e8bfd775f6b6f41cea6a6381c23547af7877d51e72dbbbf2536baaddf6869a82c2f02a23d4865d5e2\"}", + "raw_seal": "{\"id\":\"6f9005dfaf428a43d19894e353dea08739fa8624227a3de0acb9cc6480aa30ae\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994983,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"2b15387595a7fd7d1eea9bdb0d97fa8fa15305f76afabd330188ea716374273853a85df1f37309c79bf34c5e263d60d5a888cc3c666f46821d57cd32a7e7b449\"}", + "raw_rumor": "{\"id\":\"b2461138853a9b5bd29618707fbe012198d432a3f3452d418bac76449f08df53\",\"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\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":null,\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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 \\\\\\\"\\\\\\\\/ Å Å 
 
 🥬\\\",\\\"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\\\":\\\"300\\\"},\\\"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\\\",\\\"maximum\\\":\\\"2\\\",\\\"maximum_total\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"300\\\"},\\\"measurement_unit\\\":\\\"kg\\\",\\\"minimum\\\":\\\"1\\\",\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"150\\\"},\\\"type\\\":\\\"variable_weight\\\"},\\\"product\\\":{\\\"description\\\":\\\"Independent public conformance fixture\\\",\\\"name\\\":\\\"Carrots 🥕\\\",\\\"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\\\":\\\"325\\\"},\\\"rounding\\\":\\\"half_even_net_line_v1\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"supply\\\":{\\\"type\\\":\\\"stock_backed\\\"}}},\\\"profile\\\":\\\"radroots.commerce\\\",\\\"record_id\\\":\\\"c9f55ea4fc1c4619ddbdd6c447989c809167555d55c6abd495a6a6beb82e977d\\\",\\\"seller\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"thread_id\\\":\\\"7171717171717171717171717171717171717171717171717171717171717171\\\",\\\"type\\\":\\\"request\\\",\\\"version\\\":1}\"}", + "rumor_id": "b2461138853a9b5bd29618707fbe012198d432a3f3452d418bac76449f08df53", + "record_id": "c9f55ea4fc1c4619ddbdd6c447989c809167555d55c6abd495a6a6beb82e977d" } ] } diff --git a/crates/storage_sqlite/tests/support/stock_authority.rs b/crates/storage_sqlite/tests/support/stock_authority.rs @@ -602,7 +602,7 @@ async fn changed_catalog_after_protected_reads_is_refused_before_authenticated_c clock.release(); assert_eq!(operation.await, Err(WorkspaceError::RecoveryRequired)); store.close().await.unwrap(); - sqlx::query("PRAGMA user_version=8") + sqlx::query("PRAGMA user_version=9") .execute(&mut connection) .await .unwrap(); diff --git a/tools/protocol_oracle/commerce_coverage.mjs b/tools/protocol_oracle/commerce_coverage.mjs @@ -0,0 +1,42 @@ +// Independent portable scope descriptors over original synthetic signed inputs. +// This producer never calls a Radroots coverage or record implementation. +import {createHash} from 'node:crypto'; +import {readFileSync,writeFileSync} from 'node:fs'; +import assert from 'node:assert/strict'; +const root=new URL('../../',import.meta.url),sourcePath='crates/storage_sqlite/tests/fixtures/stock_history.v1.json'; +const sourceBytes=readFileSync(new URL(sourcePath,root));const source=JSON.parse(sourceBytes); +const sha=value=>createHash('sha256').update(value).digest('hex'); +const records=Object.fromEntries(source.sources.filter(row=>row.record_id!==null).map(row=>[row.name,{id:row.record_id,wire:JSON.parse(row.raw_rumor).content}])); +const chat=source.sources.find(row=>row.name==='chat').rumor_id; +const future=source.sources.find(row=>row.name==='future_commerce').rumor_id; +const unique=values=>[...new Set(values)].sort(); +function checkpoint(names,external) { + const known=unique(names.map(name=>records[name].id)); + const required=unique(names.flatMap(name=>JSON.parse(records[name].wire).parents)); + const used=unique(external.filter(id=>required.includes(id)&&!known.includes(id))); + const hash=createHash('sha256').update(Buffer.from('radroots.commerce.coverage.v1\0')); + for(const key of ['thread','order','buyer','seller'])hash.update(Buffer.from(source.scope[key],'hex')); + for(const identities of [known,used,[]]) { + const count=Buffer.alloc(8);count.writeBigUInt64BE(BigInt(identities.length));hash.update(count); + for(const id of identities) {assert.match(id,/^[0-9a-f]{64}$/);hash.update(Buffer.from(id,'hex'));} + } + return {digest:hash.digest('hex'),sequence:known.length+used.length}; +} +const external=[source.listing_id,chat]; +const base=checkpoint(['quote','request'],external); +const vectors=[ + {name:'complete',records:['quote','request'],external,uninterpreted:[],readiness:'complete',checkpoint:base}, + {name:'duplicates_and_unrelated_external',records:['request','quote','request'],external:[...external,...external,'cd'.repeat(32)],uninterpreted:[],readiness:'complete',checkpoint:base}, + {name:'withdrawal_is_relevant_evidence',records:['quote','request','withdrawal'],external,uninterpreted:[],readiness:'complete',checkpoint:checkpoint(['quote','request','withdrawal'],external)}, + {name:'seller_order_head_is_relevant',records:['quote','request','decline'],external,uninterpreted:[],readiness:'complete',checkpoint:checkpoint(['quote','request','decline'],external)}, + {name:'missing_chat',records:['quote','request'],external:[source.listing_id],uninterpreted:[],readiness:'missing_history',checkpoint:null}, + {name:'missing_quote',records:['request'],external,uninterpreted:[],readiness:'missing_history',checkpoint:null}, + {name:'author_fork',records:['quote','request','withdrawal','buyer_fork'],external,uninterpreted:[],readiness:'conflicted',checkpoint:null}, + {name:'uninterpreted',records:['quote','request'],external,uninterpreted:[future],readiness:'uninterpreted',checkpoint:null}, + {name:'empty_is_data_only',records:[],external:[],uninterpreted:[],readiness:'complete',checkpoint:checkpoint([],[])}, +]; +const output={schema_version:1,transcript:'radroots.commerce.coverage.v1: NUL domain separator, scope thread/order/buyer/seller each32bytes, then known/required available external/uninterpreted sets eachu64BE count followed by sorted unique32byte identities',producer_sha256:sha(readFileSync(new URL(import.meta.url))),source_path:sourcePath,source_sha256:sha(sourceBytes),scope:source.scope,records,vectors}; +const bytes=JSON.stringify(output,null,2)+'\n',target=new URL('crates/protocol/tests/fixtures/commerce_coverage.v1.json',root); +const args=process.argv.slice(2);assert(args.length===1&&['--write','--check'].includes(args[0])); +if(args[0]==='--write')writeFileSync(target,bytes);else assert.equal(readFileSync(target,'utf8'),bytes); +console.log(JSON.stringify({vectors:vectors.length,sha256:sha(bytes),bytes:Buffer.byteLength(bytes),check:args[0]==='--check'})); diff --git a/tools/protocol_oracle/stock_history.mjs b/tools/protocol_oracle/stock_history.mjs @@ -66,6 +66,21 @@ const wrongPrevious=record('withdrawal_requested',{authorization:requested.recor const unrelated=record('issue',{code:'other',description:'Independent unrelated scope',lines:[],source_records:[]},2,1,null,[]); unrelated.thread_id='73'.repeat(32);delete unrelated.record_id;unrelated.record_id=sha(Buffer.concat([Buffer.from('radroots.record.v1\0'),Buffer.from(canonical(unrelated))])); const rows=[chat,enclose('quote',quoted,3),enclose('request',requested,2),enclose('request_rewrapped',requested,2),enclose('withdrawal',withdrawn,2),enclose('buyer_fork',fork,2),enclose('decline',declined,3),enclose('missing_predecessor',gap,2),enclose('wrong_predecessor',wrongPrevious,2),enclose('unrelated',unrelated,2),enclose('future_commerce',canonical({profile:'radroots.commerce',version:2,type:'future_record',private_future:'Unknown authenticated statement'}),2)]; +const direct=record('request',{terms:complete,expires_at:'240',quote:null},2,1,null,[listing.id]); +const wrongSnapshot=structuredClone(complete);wrongSnapshot.lines[0].option.label='Changed copied option snapshot'; +const wrongTerms=structuredClone(complete);wrongTerms.fulfillment[0].terms.instructions+=' Changed exact quote terms.'; +const promise=structuredClone(complete);promise.supply={type:'future_promise',expected_window:{start:'300',end:'400',timezone:'Etc/UTC'},risk_disclosure:'Weather and future supply may change.'}; +const variable=structuredClone(complete);variable.lines[0].price={type:'variable_weight',measurement_unit:'kg',minimum:'1',maximum:'2',rate:{currency:'CAD',exponent:2,minor:'150'},basis:'1',maximum_total:{currency:'CAD',exponent:2,minor:'300'}}; +variable.lines[0].maximum_line_total={currency:'CAD',exponent:2,minor:'300'};variable.maximum_total={currency:'CAD',exponent:2,minor:'325'}; +for(const [name,content] of [ + ['request_no_quote',direct], + ['request_wrong_snapshot',record('request',{terms:wrongSnapshot,expires_at:'240',quote:null},2,1,null,[listing.id])], + ['request_wrong_quote_terms',record('request',{terms:wrongTerms,expires_at:'240',quote:quoted.record_id},2,1,null,[listing.id,quoted.record_id])], + ['request_early_expiry',record('request',{terms:complete,expires_at:'151',quote:quoted.record_id},2,1,null,[listing.id,quoted.record_id])], + ['request_other_order',record('request',{terms:complete,expires_at:'240',quote:null},2,1,null,[listing.id],'74'.repeat(32))], + ['request_future_promise',record('request',{terms:promise,expires_at:'240',quote:null},2,1,null,[listing.id])], + ['request_variable_weight',record('request',{terms:variable,expires_at:'240',quote:null},2,1,null,[listing.id])], +])rows.push(enclose(name,content,2)); const output={schema_version:1,scope:{thread,order,buyer,seller},listing_raw:listingRaw,listing_id:listing.id,quote:quoted.record_id,request:requested.record_id,withdrawal:withdrawn.record_id,buyer_fork:fork.record_id,decline:declined.record_id,missing,producer:{library:'nostr-tools@2.23.5',curve:'@noble/curves@2.0.1',bip340_primary_vector_zero_matched:true,script_sha256:sha(readFileSync(new URL(import.meta.url))),package_lock_sha256:sha(read('tools/protocol_oracle/package-lock.json')),redistribution_provenance_sha256:sha(read('tools/protocol_oracle/provenance.v1.json')),record_template_path:recordPath,record_template_sha256:sha(read(recordPath)),public_source_path:publicPath,public_source_sha256:sha(read(publicPath)),synthetic_only:true,production_entropy_claimed:false},sources:rows}; const bytes=JSON.stringify(output,null,2)+'\n'; const target=new URL('crates/storage_sqlite/tests/fixtures/stock_history.v1.json',root); diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -149,6 +149,7 @@ struct NativeSellerStockAuthority { operation_part_max_bytes: u32, operation_part_max_count: u16, operation_identity_requires_protected_ancestry: bool, + acceptance_preparation: AcceptancePreparation, business_consent_payload_version: u16, business_consent_action: String, business_consent_modes: Vec<String>, @@ -187,6 +188,26 @@ struct NativeSellerStockAuthority { #[derive(Deserialize)] #[serde(deny_unknown_fields)] +struct AcceptancePreparation { + planner_owner: String, + payload_version: u32, + order_payload_schema: String, + movement_payload_schema: String, + worker_charge_bytes: u32, + max_allocations: u32, + max_pool_observations: u32, + max_first_issue_window_seconds: u32, + original_replay_before_fresh_planning: bool, + complete_allocation_required: bool, + atomic_holds_and_order_fence_required: bool, + current_issued_consent_required: bool, + final_source_counts_and_witnesses_required: bool, + signer_invoked: bool, + agreement_installed: bool, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] struct Provenance { app_behavior_implementation: String, retain_source_provenance: bool, @@ -360,10 +381,10 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.scope == "seller_stock_owner" && stock.database == "stock_execution_v1.sqlite" && stock.lock == ".stock_execution_v1.lock" - && stock.schema_version == 8 + && stock.schema_version == 9 && stock.retained_enrollment_versions == [1] - && stock.retained_inventory_versions == [2, 3, 4, 5, 6, 7] - && stock.authority_payload_schema == "radroots.seller_stock.authority.v8" + && stock.retained_inventory_versions == [2, 3, 4, 5, 6, 7, 8] + && stock.authority_payload_schema == "radroots.seller_stock.authority.v9" && stock.public_source_payload_schemas == [ "radroots.seller_stock.public_source_event.v1", @@ -389,6 +410,29 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.operation_part_max_bytes == 16384 && stock.operation_part_max_count == 16 && stock.operation_identity_requires_protected_ancestry + && stock.acceptance_preparation.planner_owner == "radroots_domain" + && stock.acceptance_preparation.payload_version == 1 + && stock.acceptance_preparation.order_payload_schema + == "radroots.seller_stock.order.v1" + && stock.acceptance_preparation.movement_payload_schema + == "radroots.seller_stock.acceptance_movement.v1" + && stock.acceptance_preparation.worker_charge_bytes == 524288 + && stock.acceptance_preparation.max_allocations == 64 + && stock.acceptance_preparation.max_pool_observations == 96 + && stock.acceptance_preparation.max_first_issue_window_seconds == 120 + && stock + .acceptance_preparation + .original_replay_before_fresh_planning + && stock.acceptance_preparation.complete_allocation_required + && stock + .acceptance_preparation + .atomic_holds_and_order_fence_required + && stock.acceptance_preparation.current_issued_consent_required + && stock + .acceptance_preparation + .final_source_counts_and_witnesses_required + && !stock.acceptance_preparation.signer_invoked + && !stock.acceptance_preparation.agreement_installed && stock.business_consent_payload_version == 1 && stock.business_consent_action == "orders.accept" && stock.business_consent_modes == ["execute_and_recover", "recover_only"] @@ -1029,6 +1073,36 @@ mod tests { } #[test] + fn acceptance_requires_complete_atomic_preparation_without_signing_or_installation() { + for (field, bad) in [ + ("payload_version", json!(2)), + ("planner_owner", json!("radroots_storage_sqlite")), + ("order_payload_schema", json!("unsupported")), + ("movement_payload_schema", json!("unsupported")), + ("worker_charge_bytes", json!(524289)), + ("max_allocations", json!(65)), + ("max_pool_observations", json!(97)), + ("max_first_issue_window_seconds", json!(121)), + ("original_replay_before_fresh_planning", json!(false)), + ("complete_allocation_required", json!(false)), + ("atomic_holds_and_order_fence_required", json!(false)), + ("current_issued_consent_required", json!(false)), + ("final_source_counts_and_witnesses_required", json!(false)), + ("signer_invoked", json!(true)), + ("agreement_installed", json!(true)), + ] { + assert!( + validate_bytes(&changed( + &format!("/native_seller_stock_authority/acceptance_preparation/{field}"), + bad + )) + .is_err(), + "{field}" + ); + } + } + + #[test] fn consent_ledger_requires_bounded_parts_explicit_scopes_and_protected_identity() { for (field, bad) in [ ("schema_version", json!(6)),