lib

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

commit 8f556774fe13d6629deec185c4a43241b9708aef
parent bce54e685b87af3c9f8e3ffba99114488ff2b27b
Author: triesap <tyson@radroots.org>
Date:   Sun, 25 Oct 2026 07:44:23 +0000

storage: derive checked local commerce history

- Check scoped author chains, gaps and forks without private LWW.
- Bind native coverage to retained authenticated original sources.
- Recheck source witnesses and current access in the transaction.
- Verify independent encrypted fixtures and actual recovery races.

Diffstat:
Mcontracts/api_baselines/radroots_domain.txt | 41+++++++++++++++++++++++++++++++++++++++++
Mcontracts/api_baselines/radroots_storage_sqlite.txt | 11+++++++++++
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 7+++++++
Mcrates/domain/src/commerce.rs | 1+
Acrates/domain/src/commerce/causal.rs | 326+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/domain/src/lib.rs | 1+
Mcrates/domain/tests/listing.rs | 2++
Acrates/domain/tests/support/causal.rs | 322+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/mod.rs | 6+++---
Mcrates/storage_sqlite/src/workspace/stock.rs | 4++--
Mcrates/storage_sqlite/src/workspace/stock/public_source.rs | 1+
Acrates/storage_sqlite/src/workspace/stock/public_source/history.rs | 97+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/public_source/history_tests.rs | 500+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/public_source/test_provider.rs | 2++
Mcrates/storage_sqlite/src/workspace/stock/source.rs | 22++++++++++++++++++++++
Acrates/storage_sqlite/src/workspace/stock/source/history.rs | 377+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/src/workspace/stock/source/transaction.rs | 59+++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mcrates/storage_sqlite/src/workspace/worker.rs | 61+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/tests/fixtures/stock_history.v1.json | 132+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Atools/protocol_oracle/stock_history.mjs | 74++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mtools/xtask/src/architecture/decision_package.rs | 44++++++++++++++++++++++++++++++++++++++++++++
21 files changed, 2083 insertions(+), 7 deletions(-)

diff --git a/contracts/api_baselines/radroots_domain.txt b/contracts/api_baselines/radroots_domain.txt @@ -1,5 +1,46 @@ pub mod radroots_domain pub use radroots_domain::PublicKey +pub mod radroots_domain::causal +#[non_exhaustive] pub enum radroots_domain::causal::CausalError +pub radroots_domain::causal::CausalError::IdentityConflict +pub radroots_domain::causal::CausalError::InvalidScope +pub radroots_domain::causal::CausalError::LimitExceeded +impl core::error::Error for radroots_domain::causal::CausalError +impl core::fmt::Display for radroots_domain::causal::CausalError +pub fn radroots_domain::causal::CausalError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub enum radroots_domain::causal::CausalReadiness +pub radroots_domain::causal::CausalReadiness::Complete +pub radroots_domain::causal::CausalReadiness::Conflicted +pub radroots_domain::causal::CausalReadiness::MissingHistory +pub radroots_domain::causal::CausalReadiness::Uninterpreted +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> +pub fn radroots_domain::causal::CausalAnalysis::conflicts(&self) -> &[radroots_domain::RecordId] +pub const fn radroots_domain::causal::CausalAnalysis::has_cycle(&self) -> bool +pub fn radroots_domain::causal::CausalAnalysis::missing(&self) -> &[radroots_domain::SourceId] +pub const fn radroots_domain::causal::CausalAnalysis::quote_head(&self) -> core::option::Option<radroots_domain::RecordId> +pub const fn radroots_domain::causal::CausalAnalysis::readiness(&self) -> radroots_domain::causal::CausalReadiness +pub const fn radroots_domain::causal::CausalAnalysis::seller_head(&self) -> core::option::Option<radroots_domain::RecordId> +pub fn radroots_domain::causal::CausalAnalysis::uninterpreted(&self) -> &[radroots_domain::SourceId] +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>::new(radroots_domain::RecordId, &'a radroots_domain::CommerceContent) -> Self +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 +impl radroots_domain::causal::CausalScope +pub const fn radroots_domain::causal::CausalScope::buyer(self) -> radroots_identity::key::PublicKey +pub fn radroots_domain::causal::CausalScope::contains(self, &radroots_domain::CommerceContent) -> bool +pub fn radroots_domain::causal::CausalScope::new(radroots_domain::ThreadId, radroots_domain::OrderId, radroots_identity::key::PublicKey, radroots_identity::key::PublicKey) -> core::result::Result<Self, radroots_domain::causal::CausalError> +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 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 mod radroots_domain::listing pub enum radroots_domain::listing::FulfillmentMode pub radroots_domain::listing::FulfillmentMode::Delivery diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -418,6 +418,7 @@ pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_listing_ 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_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 @@ -498,6 +499,16 @@ impl radroots_storage_sqlite::workspace::StockGrantReceipt pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::authorization(&self) -> radroots_storage::workspace::seller_stock::authorization::StockAuthorizationRef pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::grant_id(&self) -> radroots_domain::identifier::GrantId pub const fn radroots_storage_sqlite::workspace::StockGrantReceipt::transaction_id(&self) -> radroots_domain::identifier::TransactionId +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 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 +pub const fn radroots_storage_sqlite::workspace::StockHistorySnapshot::scope(&self) -> radroots_domain::commerce::causal::CausalScope +pub const fn radroots_storage_sqlite::workspace::StockHistorySnapshot::source_checkpoint(&self) -> radroots_storage::workspace::seller_stock::source::StockSourceCheckpointRef +impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockHistorySnapshot +pub fn radroots_storage_sqlite::workspace::StockHistorySnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage_sqlite::workspace::StockListingCapture impl radroots_storage_sqlite::workspace::StockListingCapture pub const fn radroots_storage_sqlite::workspace::StockListingCapture::listing_revision(&self) -> radroots_domain::listing::reference::ListingRevision diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -176,6 +176,11 @@ "inventory_scope_grants_source_access": false, "source_checkpoint_independent": true, "source_profile_implies_actionability": false, + "causal_history_current_administrator_required": true, + "causal_history_complete_local_scope_required": true, + "causal_history_uninterpreted_policy": "conservative_authenticated_participant_pair_barrier", + "causal_history_transaction_witnesses_required": true, + "causal_history_implies_business_permission": false, "source_carrier_max_bytes": 65536, "source_chunk_max_bytes": 16384 }, @@ -655,6 +660,8 @@ "order_lines": 32, "listing_options": 16, "parent_records": 8, + "causal_records_per_scope": 1000, + "causal_source_identities_per_collection": 8000, "read_page_events": 1000, "unknown_quarantine_events_per_scope": 1024, "live_queue_events": 256, diff --git a/crates/domain/src/commerce.rs b/crates/domain/src/commerce.rs @@ -4,6 +4,7 @@ use crate::{OrderId, PublicKey, RecordId, Sequence, SourceId, Terms, ThreadId, U use alloc::{boxed::Box, vec::Vec}; use core::fmt; +pub mod causal; mod value; pub use value::{FinalMeasurement, IssueCode, IssueReport, LineQuantity, Resolution}; mod payload; diff --git a/crates/domain/src/commerce/causal.rs b/crates/domain/src/commerce/causal.rs @@ -0,0 +1,326 @@ +//! Bounded causal checks over declared records. The caller must authenticate +//! every original source and bind complete local coverage to a store checkpoint. +//! A complete result grants no participant permission or physical stock effect. +use super::{CommerceContent, CommerceType}; +use crate::{OrderId, PublicKey, RecordId, SourceId, ThreadId}; +use alloc::{ + boxed::Box, + collections::{BTreeMap, BTreeSet}, + vec, + vec::Vec, +}; +use core::fmt; + +/// One exact bilateral order scope, including seller quotes in its null-order +/// author chain. The scope itself is untrusted data, not evidence coverage. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct CausalScope { + thread: ThreadId, + order: OrderId, + buyer: PublicKey, + seller: PublicKey, +} +impl CausalScope { + /// Requires distinct parties. Original participant authentication is separate. + pub fn new( + thread: ThreadId, + order: OrderId, + buyer: PublicKey, + seller: PublicKey, + ) -> Result<Self, CausalError> { + if buyer == seller { + return Err(CausalError::InvalidScope); + } + Ok(Self { + thread, + order, + buyer, + seller, + }) + } + /// Checks exact declared thread, participants and selected/null quote order. + pub fn contains(self, content: &CommerceContent) -> bool { + let header = content.header(); + header.thread_id() == self.thread + && header.buyer() == self.buyer + && header.seller() == self.seller + && (header.order_id() == Some(self.order) + || (header.order_id().is_none() && content.record_type() == CommerceType::Quote)) + } + /// Returns the exact declared thread. + pub const fn thread_id(self) -> ThreadId { + self.thread + } + /// Returns the exact declared order. + pub const fn order_id(self) -> OrderId { + self.order + } + /// Returns the exact declared buyer. + pub const fn buyer(self) -> PublicKey { + self.buyer + } + /// Returns the exact declared seller. + pub const fn seller(self) -> PublicKey { + self.seller + } +} + +/// A borrowed content/identity claim. Hash, carrier signature and recipient +/// authentication must precede use; constructing this value does none of them. +#[derive(Clone, Copy)] +pub struct CausalRecord<'a> { + id: RecordId, + content: &'a CommerceContent, +} +impl<'a> CausalRecord<'a> { + /// 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 { + Self { id, content } + } +} +impl fmt::Debug for CausalRecord<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("CausalRecord(<untrusted claim>)") + } +} + +/// Local causal classification; even Complete is not business actionability. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum CausalReadiness { + /// All supplied required sources and author links are present and acyclic. + Complete, + /// Exact source identities are missing; fetch them before reducing actions. + MissingHistory, + /// An authenticated but uninterpreted source prevents a complete reduction. + Uninterpreted, + /// An author fork, inconsistent predecessor or causal cycle is exposed. + Conflicted, +} +/// Deterministic, input-order-independent local coverage result. Original +/// evidence and installed agreement state remain owned by their caller/store. +#[derive(Clone, Eq, PartialEq)] +pub struct CausalAnalysis { + readiness: CausalReadiness, + buyer_head: Option<RecordId>, + seller_head: Option<RecordId>, + quote_head: Option<RecordId>, + missing: Box<[SourceId]>, + conflicts: Box<[RecordId]>, + uninterpreted: Box<[SourceId]>, + cycle: bool, +} +impl CausalAnalysis { + /// Exact local coverage classification, without current business permission. + pub const fn readiness(&self) -> CausalReadiness { + self.readiness + } + /// Last contiguous uncontested buyer author-chain claim in the selected order. + pub const fn buyer_head(&self) -> Option<RecordId> { + self.buyer_head + } + /// Last contiguous uncontested seller author-chain claim in the selected order. + pub const fn seller_head(&self) -> Option<RecordId> { + self.seller_head + } + /// Last contiguous uncontested seller quote in the null-order chain. + pub const fn quote_head(&self) -> Option<RecordId> { + self.quote_head + } + /// Sorted unique exact missing references. No empty-state inference is made. + pub fn missing(&self) -> &[SourceId] { + &self.missing + } + /// Sorted exact conflicting records, including known-cycle descendants. + pub fn conflicts(&self) -> &[RecordId] { + &self.conflicts + } + /// Original retained uninterpreted identities that require reconciliation. + pub fn uninterpreted(&self) -> &[SourceId] { + &self.uninterpreted + } + /// Whether the supplied known-record dependency graph contains a cycle. + pub const fn has_cycle(&self) -> bool { + self.cycle + } +} +impl fmt::Debug for CausalAnalysis { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("CausalAnalysis(<private coverage>)") + } +} +/// Explicit resource/identity/scope failure, without private source contents. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[non_exhaustive] +pub enum CausalError { + /// More than the contracted bounded records/source references were supplied. + LimitExceeded, + /// A supplied known record belongs to another thread, order or participant pair. + InvalidScope, + /// One asserted logical identity names different complete content. + IdentityConflict, +} +impl fmt::Display for CausalError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::LimitExceeded => "causal graph limit exceeded", + Self::InvalidScope => "causal scope differs", + Self::IdentityConflict => "causal record identity conflict", + }) + } +} +impl core::error::Error for CausalError {} + +/// Maximum known records in one complete scoped causal evaluation. Larger +/// histories refuse explicitly; they are never silently truncated or paged as +/// though the first page were complete. Durable unrelated history is not capped. +pub const MAX_CAUSAL_RECORDS: usize = 1000; +/// Maximum separately verified external/uninterpreted source identities. +pub const MAX_CAUSAL_SOURCES: usize = MAX_CAUSAL_RECORDS * 8; + +fn source(id: RecordId) -> SourceId { + SourceId::from_bytes(id.into_bytes()) +} + +/// Checks the complete supplied local scoped graph with no recursion or clock. +/// External sources cannot stand in for an author predecessor. Uninterpreted +/// authenticated evidence remains a barrier, including when no known node +/// happens to reference it. Source completeness/authenticity remains a mandatory +/// store/ingress obligation; this pure function cannot discover omitted records. +pub fn analyze( + scope: CausalScope, + records: &[CausalRecord<'_>], + external_sources: &[SourceId], + uninterpreted_sources: &[SourceId], +) -> Result<CausalAnalysis, CausalError> { + if records.len() > MAX_CAUSAL_RECORDS + || external_sources.len() > MAX_CAUSAL_SOURCES + || uninterpreted_sources.len() > MAX_CAUSAL_SOURCES + { + return Err(CausalError::LimitExceeded); + } + let mut unique = BTreeMap::<SourceId, CausalRecord<'_>>::new(); + for record in records { + if !scope.contains(record.content) { + return Err(CausalError::InvalidScope); + } + if let Some(previous) = unique.insert(source(record.id), *record) + && previous.content != record.content + { + return Err(CausalError::IdentityConflict); + } + } + // Stable identity ordering makes traversal and diagnostics independent of + // relay arrival order and caller ordering. No timestamp wins a private fork. + let nodes: Vec<_> = unique.values().copied().collect(); + let positions: BTreeMap<_, _> = nodes + .iter() + .enumerate() + .map(|(index, node)| (source(node.id), index)) + .collect(); + let external: BTreeSet<_> = external_sources.iter().copied().collect(); + let uninterpreted: BTreeSet<_> = uninterpreted_sources.iter().copied().collect(); + let mut slots = BTreeMap::new(); + let mut conflicts = BTreeSet::new(); + let mut missing = BTreeSet::new(); + for node in &nodes { + let header = node.content.header(); + let slot = ( + header.author(), + header.order_id(), + header.author_sequence().get(), + ); + if let Some(prior) = slots.insert(slot, node.id) { + conflicts.insert(prior); + conflicts.insert(node.id); + } + for parent in header.parents() { + if !positions.contains_key(parent) + && !external.contains(parent) + && !uninterpreted.contains(parent) + { + missing.insert(*parent); + } + } + if let Some(previous) = header.author_previous() { + if let Some(index) = positions.get(&source(previous)) { + let prior = nodes[*index].content.header(); + if prior.author() != header.author() + || prior.thread_id() != header.thread_id() + || prior.order_id() != header.order_id() + || prior.buyer() != header.buyer() + || prior.seller() != header.seller() + || prior.author_sequence().get().checked_add(1) + != Some(header.author_sequence().get()) + { + conflicts.insert(node.id); + } + } else { + // A generic existing source or uninterpreted carrier cannot + // prove the declared predecessor's author/scope/sequence. + missing.insert(source(previous)); + } + } + } + // Iterative topological traversal bounds both stack and work by the explicit + // record budget. Missing external parents are reported separately; they do + // not manufacture a false cycle in the known dependency subgraph. + let mut visited = vec![false; nodes.len()]; + loop { + let mut progress = false; + for (index, node) in nodes.iter().enumerate() { + if !visited[index] + && node + .content + .header() + .parents() + .iter() + .all(|parent| positions.get(parent).is_none_or(|parent| visited[*parent])) + { + visited[index] = true; + progress = true; + } + } + if !progress { + break; + } + } + let cycle = visited.iter().any(|visited| !visited); + for (node, visited) in nodes.iter().zip(&visited) { + if !visited { + conflicts.insert(node.id); + } + } + let head = |author, order| { + let mut previous = None; + let mut sequence = 1; + while let Some(id) = slots.get(&(author, order, sequence)).copied() { + let node = &nodes[positions[&source(id)]]; + if conflicts.contains(&id) || node.content.header().author_previous() != previous { + break; + } + previous = Some(id); + sequence += 1; + } + previous + }; + let readiness = if !conflicts.is_empty() { + CausalReadiness::Conflicted + } else if !uninterpreted.is_empty() { + CausalReadiness::Uninterpreted + } else if !missing.is_empty() { + CausalReadiness::MissingHistory + } else { + CausalReadiness::Complete + }; + Ok(CausalAnalysis { + readiness, + buyer_head: head(scope.buyer, Some(scope.order)), + seller_head: head(scope.seller, Some(scope.order)), + quote_head: head(scope.seller, None), + missing: missing.into_iter().collect(), + conflicts: conflicts.into_iter().collect(), + uninterpreted: uninterpreted.into_iter().collect(), + cycle, + }) +} diff --git a/crates/domain/src/lib.rs b/crates/domain/src/lib.rs @@ -32,6 +32,7 @@ pub use agreement::{ SupplyCommitment, Terms, TermsError, }; pub use amount::{AmountError, Decimal, PositiveDecimal}; +pub use commerce::causal; pub use commerce::{ AgreementCommitment, CancellationProposal, CommerceContent, CommerceError, CommerceHeader, CommercePayload, CommerceType, FinalMeasurement, HandoverClaim, IssueCode, IssueReport, diff --git a/crates/domain/tests/listing.rs b/crates/domain/tests/listing.rs @@ -9,6 +9,8 @@ mod time; #[path = "support/agreement.rs"] mod agreement; +#[path = "support/causal.rs"] +mod causal; #[path = "support/commerce.rs"] mod commerce; diff --git a/crates/domain/tests/support/causal.rs b/crates/domain/tests/support/causal.rs @@ -0,0 +1,322 @@ +use super::agreement::{buyer, group, line, money, seller, terms}; +use radroots_domain::{causal::*, *}; + +fn id(value: u64) -> RecordId { + let mut out = [0; 32]; + out[24..].copy_from_slice(&value.to_be_bytes()); + RecordId::from_bytes(out) +} +fn src(value: u64) -> SourceId { + SourceId::from_bytes(id(value).into_bytes()) +} +fn order() -> OrderId { + OrderId::from_bytes([2; 32]) +} +fn thread() -> ThreadId { + ThreadId::from_bytes([1; 32]) +} +fn scope() -> CausalScope { + CausalScope::new(thread(), order(), buyer(), seller()).unwrap() +} +fn make(author: PublicKey, sequence: u64, previous: Option<u64>, extra: &[u64]) -> CommerceContent { + let mut parents = vec![src(9000)]; + parents.extend(previous.map(src)); + parents.extend(extra.iter().copied().map(src)); + parents.sort(); + parents.dedup(); + let header = CommerceHeader::new( + thread(), + Some(order()), + author, + buyer(), + seller(), + UnixSeconds::new(100).unwrap(), + Sequence::new(sequence).unwrap(), + previous.map(id), + parents, + ) + .unwrap(); + let reason = RecordReason::new(id(9000), "private reason").unwrap(); + let payload = if author == seller() { + CommercePayload::Decline(reason) + } else { + CommercePayload::WithdrawalRequested(reason) + }; + CommerceContent::new(header, payload).unwrap() +} +fn evaluate( + values: &[(u64, CommerceContent)], + external: &[u64], + uninterpreted: &[u64], +) -> CausalAnalysis { + analyze( + scope(), + &values + .iter() + .map(|(identity, content)| CausalRecord::new(id(*identity), content)) + .collect::<Vec<_>>(), + &external.iter().copied().map(src).collect::<Vec<_>>(), + &uninterpreted.iter().copied().map(src).collect::<Vec<_>>(), + ) + .unwrap() +} + +#[test] +fn every_arrival_order_and_exact_duplicates_preserve_both_complete_author_heads() { + let values = [ + (1, make(seller(), 1, None, &[])), + (2, make(buyer(), 1, None, &[1])), + (3, make(seller(), 2, Some(1), &[2])), + (4, make(buyer(), 2, Some(2), &[3])), + ]; + let expected = evaluate(&values, &[9000], &[]); + assert_eq!(expected.readiness(), CausalReadiness::Complete); + assert_eq!(expected.seller_head(), Some(id(3))); + assert_eq!(expected.buyer_head(), Some(id(4))); + assert_eq!(expected.quote_head(), None); + for a in 0..4 { + for b in 0..4 { + for c in 0..4 { + for d in 0..4 { + let indices = [a, b, c, d]; + if (0..4).any(|i| indices[..i].contains(&indices[i])) { + continue; + } + let shuffled = indices.map(|i| values[i].clone()); + assert_eq!(evaluate(&shuffled, &[9000], &[]), expected); + let duplicated = [shuffled.as_slice(), &shuffled[..2]].concat(); + assert_eq!(evaluate(&duplicated, &[9000], &[]), expected); + } + } + } + } + assert!(!expected.has_cycle()); + assert!(expected.missing().is_empty()); + assert!(expected.conflicts().is_empty()); +} + +#[test] +fn exact_missing_predecessors_cannot_be_satisfied_by_generic_sources_or_empty_history() { + let values = [(2, make(buyer(), 2, Some(1), &[5, 6]))]; + let result = evaluate(&values, &[9000, 1, 5], &[]); + assert_eq!(result.readiness(), CausalReadiness::MissingHistory); + assert_eq!(result.missing(), [src(1), src(6)]); + assert_eq!(result.buyer_head(), None); + assert!(!result.has_cycle()); + let result = evaluate(&values, &[9000], &[1]); + assert_eq!(result.readiness(), CausalReadiness::Uninterpreted); + assert!(result.missing().contains(&src(1))); + let empty = evaluate(&[], &[], &[]); + assert_eq!(empty.readiness(), CausalReadiness::Complete); + assert_eq!(empty.buyer_head(), None); + // Complete describes only supplied coverage; it cannot invent a request. +} + +#[test] +fn incompatible_same_sequence_records_expose_all_forks_and_retain_only_the_uncontested_prefix() { + let values = [ + (1, make(seller(), 1, None, &[])), + (2, make(seller(), 2, Some(1), &[])), + (3, make(seller(), 2, Some(1), &[20])), + (4, make(seller(), 3, Some(2), &[])), + (5, make(seller(), 2, Some(1), &[21])), + ]; + let expected = evaluate(&values, &[9000, 20, 21], &[]); + assert_eq!(expected.readiness(), CausalReadiness::Conflicted); + assert_eq!(expected.seller_head(), Some(id(1))); + assert_eq!(expected.conflicts(), [id(2), id(3), id(5)]); + assert!(!expected.has_cycle()); + for rotation in 0..values.len() { + let mut reversed = values.to_vec(); + reversed.rotate_left(rotation); + reversed.reverse(); + assert_eq!(evaluate(&reversed, &[9000, 21, 20], &[]), expected); + } +} + +#[test] +fn predecessor_author_and_sequence_mismatches_block_contiguous_heads() { + for values in [ + vec![ + (1, make(seller(), 1, None, &[])), + (2, make(buyer(), 2, Some(1), &[])), + ], + vec![ + (1, make(seller(), 1, None, &[])), + (2, make(seller(), 3, Some(1), &[])), + ], + ] { + let result = evaluate(&values, &[9000], &[]); + assert_eq!(result.readiness(), CausalReadiness::Conflicted); + assert_eq!(result.conflicts(), [id(2)]); + assert_eq!(result.buyer_head(), None); + assert_eq!(result.seller_head(), Some(id(1))); + } +} + +#[test] +fn cross_author_cycles_and_descendants_are_bounded_and_never_timestamp_ranked() { + let values = [ + (1, make(seller(), 1, None, &[2])), + (2, make(buyer(), 1, None, &[1])), + (3, make(buyer(), 2, Some(2), &[])), + ]; + let result = evaluate(&values, &[9000], &[]); + assert_eq!(result.readiness(), CausalReadiness::Conflicted); + assert!(result.has_cycle()); + assert_eq!(result.conflicts(), [id(1), id(2), id(3)]); + assert_eq!(result.buyer_head(), None); + assert_eq!(result.seller_head(), None); + let missing_only = evaluate(&[(1, make(seller(), 1, None, &[2]))], &[9000], &[]); + assert!(!missing_only.has_cycle()); + assert_eq!(missing_only.readiness(), CausalReadiness::MissingHistory); +} + +#[test] +fn authenticated_uninterpreted_evidence_blocks_reduction_even_when_not_referenced_by_known_nodes() { + let values = [(1, make(seller(), 1, None, &[]))]; + let result = evaluate(&values, &[9000, 44], &[44, 43, 44]); + assert_eq!(result.readiness(), CausalReadiness::Uninterpreted); + assert_eq!(result.uninterpreted(), [src(43), src(44)]); + assert!(result.missing().is_empty()); + assert_eq!(result.seller_head(), Some(id(1))); +} + +fn quote(sequence: u64, previous: Option<u64>) -> CommerceContent { + let mut parents = vec![SourceId::from_bytes([3; 32])]; + parents.extend(previous.map(src)); + parents.sort(); + let header = CommerceHeader::new( + thread(), + None, + seller(), + buyer(), + seller(), + UnixSeconds::new(100).unwrap(), + Sequence::new(sequence).unwrap(), + previous.map(id), + parents, + ) + .unwrap(); + let complete = terms(vec![line(7, 9)], vec![group(9)], money("50"), money("700")).unwrap(); + CommerceContent::new( + header, + CommercePayload::Quote(TermsQuote::new( + complete, + UnixSeconds::new(200).unwrap(), + None, + )), + ) + .unwrap() +} +#[test] +fn null_order_quote_chains_remain_separate_from_the_same_seller_order_chain() { + let values = [ + (1, quote(1, None)), + (2, quote(2, Some(1))), + (3, make(seller(), 1, None, &[2])), + ]; + let external = [src(9000), SourceId::from_bytes([3; 32])]; + let records = values + .iter() + .map(|(i, c)| CausalRecord::new(id(*i), c)) + .collect::<Vec<_>>(); + let result = analyze(scope(), &records, &external, &[]).unwrap(); + assert_eq!(result.readiness(), CausalReadiness::Complete); + assert_eq!(result.quote_head(), Some(id(2))); + assert_eq!(result.seller_head(), Some(id(3))); + let bad = make(seller(), 3, Some(2), &[]); + let mut records = records; + records.push(CausalRecord::new(id(4), &bad)); + let result = analyze(scope(), &records, &external, &[]).unwrap(); + assert_eq!(result.readiness(), CausalReadiness::Conflicted); + assert!(result.conflicts().contains(&id(4))); +} + +#[test] +fn mixed_scope_and_same_identity_changed_complete_payload_are_explicit_errors() { + let first = make(seller(), 1, None, &[]); + let second = make(seller(), 1, None, &[22]); + assert_eq!( + analyze( + scope(), + &[ + CausalRecord::new(id(1), &first), + CausalRecord::new(id(1), &second) + ], + &[src(9000), src(22)], + &[] + ) + .unwrap_err(), + CausalError::IdentityConflict + ); + for different in [ + CausalScope::new(ThreadId::from_bytes([9; 32]), order(), buyer(), seller()).unwrap(), + CausalScope::new(thread(), OrderId::from_bytes([9; 32]), buyer(), seller()).unwrap(), + CausalScope::new(thread(), order(), seller(), buyer()).unwrap(), + ] { + assert_eq!( + analyze(different, &[CausalRecord::new(id(1), &first)], &[], &[]).unwrap_err(), + CausalError::InvalidScope + ); + } + assert_eq!( + CausalScope::new(thread(), order(), seller(), seller()), + Err(CausalError::InvalidScope) + ); +} + +#[test] +fn maximum_reverse_dependency_chain_is_iterative_and_limits_never_silently_truncate() { + assert_eq!(MAX_CAUSAL_RECORDS, 1000); + assert_eq!(MAX_CAUSAL_SOURCES, 8000); + let values = (1..=MAX_CAUSAL_RECORDS as u64) + .map(|sequence| { + ( + 1001 - sequence, + make( + seller(), + sequence, + (sequence > 1).then_some(1002 - sequence), + &[], + ), + ) + }) + .collect::<Vec<_>>(); + let result = evaluate(&values, &[9000], &[]); + assert_eq!(result.readiness(), CausalReadiness::Complete); + assert_eq!(result.seller_head(), Some(id(1))); + let records = values + .iter() + .map(|(i, c)| CausalRecord::new(id(*i), c)) + .collect::<Vec<_>>(); + let mut excess = records.clone(); + excess.push(records[0]); + assert_eq!( + analyze(scope(), &excess, &[src(9000)], &[]).unwrap_err(), + CausalError::LimitExceeded + ); + for (external, uninterpreted) in [(vec![src(9); 8001], vec![]), (vec![], vec![src(9); 8001])] { + assert_eq!( + analyze(scope(), &records, &external, &uninterpreted).unwrap_err(), + CausalError::LimitExceeded + ); + } +} + +#[test] +fn diagnostics_do_not_copy_private_contents_or_claim_permission() { + let content = make(seller(), 1, None, &[]); + let record = CausalRecord::new(id(1), &content); + assert_eq!(format!("{record:?}"), "CausalRecord(<untrusted claim>)"); + let result = analyze(scope(), &[record], &[src(9000)], &[]).unwrap(); + assert_eq!(format!("{result:?}"), "CausalAnalysis(<private coverage>)"); + for error in [ + CausalError::InvalidScope, + CausalError::IdentityConflict, + CausalError::LimitExceeded, + ] { + assert!(error.to_string().len() < 64); + assert!(core::error::Error::source(&error).is_none()); + } +} diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs @@ -25,9 +25,9 @@ mod stock; pub use stock::{ SellerStockConfig, StockAuthorityReceipt, StockConsentCapture, StockConsentMode, StockConsentOutcome, StockConsentReceipt, StockEnrollment, StockGrantEnrollment, - StockGrantOutcome, StockGrantReceipt, StockListingCapture, StockListingOutcome, - StockListingReceipt, StockListingSnapshot, StockSourceCapture, StockSourceOutcome, - StockSourceProfile, StockSourceReceipt, StockSourceSnapshot, + StockGrantOutcome, StockGrantReceipt, StockHistorySnapshot, StockListingCapture, + StockListingOutcome, StockListingReceipt, StockListingSnapshot, 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 @@ -23,8 +23,8 @@ use grants::StockRecord; pub use grants::{StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt}; use serde::{Deserialize, Serialize}; pub use source::{ - StockSourceCapture, StockSourceOutcome, StockSourceProfile, StockSourceReceipt, - StockSourceSnapshot, + StockHistorySnapshot, StockSourceCapture, StockSourceOutcome, StockSourceProfile, + StockSourceReceipt, StockSourceSnapshot, }; use sqlx::{Connection, SqliteConnection}; use std::{ diff --git a/crates/storage_sqlite/src/workspace/stock/public_source.rs b/crates/storage_sqlite/src/workspace/stock/public_source.rs @@ -9,6 +9,7 @@ use radroots_event::envelope::event_head::EventHeadCoordinate; use radroots_nostr::public_ingress::ObservedHead; use zeroize::Zeroizing; mod checkpoint; +pub(in crate::workspace::stock) mod history; mod record; #[cfg(test)] mod tests; diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/history.rs b/crates/storage_sqlite/src/workspace/stock/public_source/history.rs @@ -0,0 +1,97 @@ +//! Batched historical identity checks for causal reads. Historical existence +//! never grants permission to request against an old or unsupported offer. +use super::*; +use checkpoint::{Proof, Target}; +use radroots_domain::{Sequence, SourceId}; +use radroots_storage::{ + command::OperationError, workspace::seller_stock::StockListingCheckpointRef, +}; +use std::collections::BTreeSet; + +pub(in crate::workspace::stock) struct Witness { + minimum: Proof, + all: Proof, + progress: PublicSourceCheckpoint, + originals: Vec<(EnvelopeEventId, u8, [u8; 32])>, + present: Vec<SourceId>, +} +impl Witness { + pub(in crate::workspace::stock) fn present(&self) -> &[SourceId] { + &self.present + } + pub(in crate::workspace::stock) async fn confirm( + &self, + connection: &mut SqliteConnection, + ) -> Result<(), OperationError> { + counts(connection, self.progress).await?; + self.minimum.confirm(connection).await?; + self.all.confirm(connection).await?; + for (event, count, digest) in &self.originals { + if record::parts_witness(connection, *event).await? != (*count, *digest) { + return Err(OperationError::RecoveryRequired); + } + } + Ok(()) + } +} +pub(in crate::workspace::stock) async fn prepare( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + authority: &Authority, + minimum: StockListingCheckpointRef, + wanted: &BTreeSet<SourceId>, +) -> Result<Witness, OperationError> { + if wanted.len() > radroots_domain::causal::MAX_CAUSAL_SOURCES { + return Err(WorkspaceError::Capacity.into()); + } + if minimum.authorization() != authority.authorization { + return Err(WorkspaceError::StaleCheckpoint.into()); + } + let progress = authority + .public_sources + .ok_or(OperationError::UnsupportedOperation)?; + let minimum = checkpoint::authenticate( + connection, + input, + crypto, + authority, + Target::Minimum(minimum), + ) + .await?; + // One complete protected walk proves all requested presence/absence claims. + // Repeating a full walk independently for every missing parent would make + // scoped reads multiply unrelated public-history cost by the parent count. + let genesis = StockListingCheckpointRef::from_host_metadata( + input.authority(), + Sequence::new(0).map_err(|_| OperationError::RecoveryRequired)?, + None, + )?; + let all = checkpoint::authenticate( + connection, + input, + crypto, + authority, + Target::Minimum(genesis), + ) + .await?; + let mut originals = Vec::new(); + let mut present = Vec::new(); + for source in wanted { + let event = EnvelopeEventId::from_bytes(source.into_bytes()); + if let Some(retained) = + record::read(connection, input, crypto, authority.input.grant_id(), event).await? + { + let parts = record::read_parts(connection, input, crypto, &retained.header).await?; + originals.push((event, retained.header.manifest.parts, parts.witness)); + present.push(*source); + } + } + Ok(Witness { + minimum, + all, + progress, + originals, + present, + }) +} 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 @@ -0,0 +1,500 @@ +//! Real NIP59/NIP44 source admission and actual native causal coverage. The +//! independent producer does not call a Radroots record/envelope constructor. +use super::*; +use radroots_domain::{ + RecordId, SourceId, + causal::{CausalReadiness, CausalScope}, +}; +use radroots_nostr::{commerce, key::SecretKey, signing::LocalSigner}; +use radroots_signing::{provider::ProviderCall, request::CancellationSignal}; +use radroots_storage::workspace::seller_stock::StockSourceCheckpointRef; +use std::num::NonZeroU64; + +fn data() -> serde_json::Value { + serde_json::from_str(include_str!( + "../../../../tests/fixtures/stock_history.v1.json" + )) + .unwrap() +} +fn scope() -> CausalScope { + let value = data(); + let value = &value["scope"]; + 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 identity(name: &str) -> RecordId { + data()[name].as_str().unwrap().parse().unwrap() +} +fn source(name: &str) -> SourceId { + SourceId::from_bytes(identity(name).into_bytes()) +} +async fn retain(r: &Rig, name: &str) { + let fixture = data(); + let row = fixture["sources"] + .as_array() + .unwrap() + .iter() + .find(|row| row["name"] == name) + .unwrap(); + let signer = LocalSigner::with_clock( + SecretKey::parse(&format!( + "{:064x}", + row["recipient_scalar"].as_u64().unwrap() + )) + .unwrap(), + || Ok(1000), + ) + .unwrap(); + assert_eq!(signer.public_key(), r.enrollment.input().participant()); + let call = ProviderCall::new( + signer.public_key(), + NonZeroU64::new(2000).unwrap(), + CancellationSignal::new(), + ); + let opened = commerce::open(&signer, call, row["raw_wrap"].as_str().unwrap()) + .await + .unwrap(); + let capture = StockSourceCapture::prepare( + SellerAuthoritySelection::from_attachment(r.enrollment.input()), + &opened, + ) + .unwrap(); + let expected = if name == "chat" || name == "future_commerce" { + StockSourceProfile::Unsupported + } else { + StockSourceProfile::Known + }; + assert_eq!(capture.profile(), expected, "{name}"); + let (minimum, _) = minima(r).await; + assert!(matches!( + r.store + .retain_stock_source(r.binding.clone(), minimum, &capture, r.enrollment.proof()) + .await + .unwrap(), + StockSourceOutcome::Committed(_) + )); +} +async fn minima(r: &Rig) -> (StockSourceCheckpointRef, StockListingCheckpointRef) { + let current = r + .store + .stock_authority(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap(); + ( + current.source_checkpoint().unwrap(), + current.listing_checkpoint().unwrap(), + ) +} +async fn history(r: &Rig) -> StockHistorySnapshot { + let (private, public) = minima(r).await; + r.store + .stock_order_history( + r.binding.clone(), + private, + public, + scope(), + r.enrollment.proof(), + ) + .await + .unwrap() +} +async fn base(r: &Rig) { + assert_eq!( + data()["listing_raw"].as_str().unwrap(), + vector("listing_fixed") + ); + r.retain(&r.capture("listing_fixed")).await; + for name in ["request", "quote", "chat"] { + retain(r, name).await; + } +} + +#[tokio::test] +async fn all_independent_sources_have_their_exact_original_authenticated_profile_disposition() { + let r = Rig::new().await; + let fixture = data(); + for row in fixture["sources"].as_array().unwrap() { + retain(&r, row["name"].as_str().unwrap()).await; + } + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn seller_order_chain_begins_separately_from_the_original_null_order_quote() { + let r = Rig::new().await; + base(&r).await; + retain(&r, "decline").await; + let result = history(&r).await; + assert_eq!(result.analysis().readiness(), CausalReadiness::Complete); + assert_eq!(result.analysis().quote_head(), Some(identity("quote"))); + assert_eq!(result.analysis().seller_head(), Some(identity("decline"))); + assert_eq!(result.analysis().buyer_head(), Some(identity("request"))); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn real_original_missing_sources_become_complete_only_after_exact_history_arrives_and_reopen_retains_it() + { + let mut r = Rig::new().await; + retain(&r, "request").await; + let missing = history(&r).await; + assert_eq!( + missing.analysis().readiness(), + CausalReadiness::MissingHistory + ); + let mut expected = vec![source("listing_id"), source("quote")]; + expected.sort(); + assert_eq!(missing.analysis().missing(), expected); + retain(&r, "quote").await; + retain(&r, "chat").await; + assert_eq!( + history(&r).await.analysis().missing(), + [source("listing_id")] + ); + r.retain(&r.capture("listing_fixed")).await; + let before = minima(&r).await; + let complete = history(&r).await; + 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"))); + assert_eq!(complete.analysis().seller_head(), None); + assert_eq!(complete.known_records(), 2); + assert_eq!(complete.source_checkpoint(), before.0); + assert_eq!(complete.listing_checkpoint(), before.1); + assert_eq!(complete.observed_at().get(), 150); + assert_eq!(minima(&r).await, before); + retain(&r, "request_rewrapped").await; + retain(&r, "unrelated").await; + assert_eq!(history(&r).await.analysis(), complete.analysis()); + assert_eq!(history(&r).await.known_records(), 2); + 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!(history(&r).await.analysis(), complete.analysis()); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn actual_withdrawal_and_authenticated_author_fork_are_exposed_without_timestamp_winners_or_inventory_effects() + { + let r = Rig::new().await; + base(&r).await; + let stock = r + .store + .stock_authority(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap() + .inventory_checkpoint(); + retain(&r, "withdrawal").await; + let withdrawal = history(&r).await; + assert_eq!(withdrawal.analysis().readiness(), CausalReadiness::Complete); + assert_eq!( + withdrawal.analysis().buyer_head(), + Some(identity("withdrawal")) + ); + retain(&r, "buyer_fork").await; + let fork = history(&r).await; + 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")]; + expected.sort(); + assert_eq!(fork.analysis().conflicts(), expected); + assert_eq!( + r.store + .stock_authority(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap() + .inventory_checkpoint(), + stock + ); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn actual_missing_and_wrong_predecessors_do_not_manufacture_genesis_or_cross_quote_author_scope() + { + for name in ["missing_predecessor", "wrong_predecessor"] { + let r = Rig::new().await; + base(&r).await; + retain(&r, name).await; + let result = history(&r).await; + assert_eq!(result.analysis().buyer_head(), Some(identity("request"))); + if name == "missing_predecessor" { + assert_eq!( + result.analysis().readiness(), + CausalReadiness::MissingHistory + ); + assert_eq!(result.analysis().missing(), [source("missing")]); + } else { + assert_eq!(result.analysis().readiness(), CausalReadiness::Conflicted); + assert_eq!(result.analysis().conflicts().len(), 1); + } + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn ordinary_chat_is_a_source_but_uninterpretable_authenticated_commerce_blocks_the_pair() { + let r = Rig::new().await; + base(&r).await; + assert_eq!( + history(&r).await.analysis().readiness(), + CausalReadiness::Complete + ); + retain(&r, "future_commerce").await; + let result = history(&r).await; + assert_eq!( + result.analysis().readiness(), + CausalReadiness::Uninterpreted + ); + assert_eq!(result.analysis().uninterpreted().len(), 1); + assert!(result.analysis().missing().is_empty()); + assert_eq!(result.analysis().buyer_head(), Some(identity("request"))); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn physical_grants_and_forked_source_acknowledgments_cannot_read_private_history() { + let r = Rig::new().await; + base(&r).await; + let old = minima(&r).await; + let inventory = r + .store + .stock_authority(r.enrollment.input().clone(), r.enrollment.proof()) + .await + .unwrap() + .inventory_checkpoint() + .unwrap(); + let child = StockGrantEnrollment::prepare( + &SellerAuthoritySelection::from_attachment(r.enrollment.input()), + "physical".into(), + UnixSeconds::new(290).unwrap(), + StockGrantScope::full_inventory(), + ) + .unwrap(); + assert!(matches!( + r.store + .enroll_stock_grant(r.binding.clone(), inventory, r.enrollment.proof(), &child) + .await + .unwrap(), + StockGrantOutcome::Committed(_) + )); + let child_binding = r + .store + .authenticate(child.input().clone(), child.proof()) + .await + .unwrap(); + let current = minima(&r).await; + assert_eq!( + r.store + .stock_order_history(child_binding, current.0, current.1, scope(), child.proof()) + .await + .unwrap_err() + .code(), + "unauthorized" + ); + assert_eq!( + r.store + .stock_order_history( + r.binding.clone(), + old.0, + old.1, + scope(), + r.enrollment.proof() + ) + .await + .unwrap_err() + .code(), + "stale_checkpoint" + ); + let fork = StockSourceCheckpointRef::from_host_metadata( + r.enrollment.input().authority(), + current.0.revision(), + Some(radroots_domain::CheckpointDigest::from_bytes([0x44; 32])), + ) + .unwrap() + .with_optional_authorization(current.0.authorization()); + assert_eq!( + r.store + .stock_order_history( + r.binding.clone(), + fork, + current.1, + scope(), + r.enrollment.proof() + ) + .await + .unwrap_err() + .code(), + "stale_checkpoint" + ); + assert_eq!( + history(&r).await.analysis().readiness(), + CausalReadiness::Complete + ); + r.store.close().await.unwrap(); +} + +#[tokio::test] +async fn causal_reads_recheck_real_canonical_rumor_and_listing_rows_after_successful_provider_opening() + { + for (schema, statement) in [ + ( + "radroots.seller_stock.source_record.v1", + "UPDATE stock_source_records SET protected=randomblob(length(protected)) WHERE record_id=?", + ), + ( + "radroots.seller_stock.source_part.v1", + "UPDATE stock_source_parts SET protected=randomblob(length(protected)) WHERE role=2 AND envelope_id=?", + ), + ( + "radroots.seller_stock.public_source_part.v1", + "UPDATE stock_public_parts SET protected=randomblob(length(protected)) WHERE event_id=?", + ), + ] { + 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, schema, 0); + let mut future = Box::pin(r.store.stock_order_history( + r.binding.clone(), + private, + public, + scope(), + r.enrollment.proof(), + )); + assert!(futures::poll!(future.as_mut()).is_pending()); + provider.gate.entered(); + let key = match schema { + "radroots.seller_stock.source_record.v1" => identity("request").into_bytes().to_vec(), + "radroots.seller_stock.source_part.v1" => { + let fixture = data(); + let row = fixture["sources"] + .as_array() + .unwrap() + .iter() + .find(|row| row["name"] == "chat") + .unwrap(); + let outer: serde_json::Value = + serde_json::from_str(row["raw_wrap"].as_str().unwrap()).unwrap(); + outer["id"] + .as_str() + .unwrap() + .parse::<EnvelopeEventId>() + .unwrap() + .into_bytes() + .to_vec() + } + _ => identity("listing_id").into_bytes().to_vec(), + }; + assert_eq!( + sqlx::query(statement) + .bind(key) + .execute(&mut raw) + .await + .unwrap() + .rows_affected(), + 1 + ); + provider.gate.release(); + assert_eq!(future.await.unwrap_err().code(), "recovery_required"); + raw.close().await.unwrap(); + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn causal_snapshot_reports_the_actual_final_checked_time_and_rejects_expiry_after_provider_io() + { + for at in [299, 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", + 0, + ); + let mut future = Box::pin(r.store.stock_order_history( + r.binding.clone(), + private, + public, + scope(), + 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; + if at == 299 { + assert_eq!(result.unwrap().observed_at().get(), 299); + } else { + assert_eq!(result.unwrap_err().code(), "grant_expired"); + } + r.store.close().await.unwrap(); + } +} + +#[tokio::test] +async fn observer_loss_does_not_abandon_admitted_history_work_or_release_the_owner_early() { + 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", + 0, + ); + let mut future = Box::pin(r.store.stock_order_history( + r.binding.clone(), + private, + public, + scope(), + r.enrollment.proof(), + )); + assert!(futures::poll!(future.as_mut()).is_pending()); + provider.gate.entered(); + drop(future); + 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!( + history(&r).await.analysis().readiness(), + CausalReadiness::Complete + ); + assert_eq!(minima(&r).await, (private, public)); + 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 @@ -1,4 +1,6 @@ use super::*; +#[path = "history_tests.rs"] +mod history; use radroots_secrets::{ Error, file::FileProvider, diff --git a/crates/storage_sqlite/src/workspace/stock/source.rs b/crates/storage_sqlite/src/workspace/stock/source.rs @@ -9,8 +9,11 @@ use radroots_storage::{ use sha2::{Digest, Sha256}; use zeroize::Zeroizing; mod checkpoint; +mod history; +pub use history::StockHistorySnapshot; mod record; mod transaction; +pub(in crate::workspace) use transaction::history as query_history; pub(in crate::workspace) use transaction::{query, retain}; /// Authenticated carrier/profile disposition, without causal actionability. @@ -247,6 +250,25 @@ impl std::fmt::Debug for StockSourceSnapshot { } } impl NativeWorkspace { + /// 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. + /// Uninterpreted commerce from either party conservatively blocks that pair + /// because its future header cannot yet be scoped. Ordinary chat remains a + /// separate source and never becomes a structured record by interpretation. + pub async fn stock_order_history( + &self, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + listing_minimum: radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + scope: radroots_domain::causal::CausalScope, + proof: &AttachmentProof, + ) -> Result<StockHistorySnapshot, OperationError> { + let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; + self.worker + .stock_order_history(binding, minimum, listing_minimum, scope, proof) + .await + } /// Retains original authenticated evidence on the selected owner worker. /// Borrowed capture/proof remain available after error or observer loss. pub async fn retain_stock_source( diff --git a/crates/storage_sqlite/src/workspace/stock/source/history.rs b/crates/storage_sqlite/src/workspace/stock/source/history.rs @@ -0,0 +1,377 @@ +//! Complete protected local scoped causal coverage. This read supplies no +//! request permission, current-offer permission, installed order or stock hold. +use super::*; +use radroots_domain::{ + SourceId, UnixSeconds, + causal::{self, CausalAnalysis, CausalRecord, CausalScope}, +}; +use radroots_protocol::{commerce::DecodedRecord, private_rumor::DecodedRumor}; +use radroots_storage::workspace::seller_stock::StockListingCheckpointRef; +use sqlx::Row; +use std::collections::{BTreeMap, BTreeSet}; + +/// Checked retained local causal coverage at independently acknowledged private +/// and public checkpoints. This grants no request, agreement or stock authority. +pub struct StockHistorySnapshot { + pub(super) scope: CausalScope, + pub(super) analysis: CausalAnalysis, + pub(super) sources: StockSourceCheckpointRef, + pub(super) listings: StockListingCheckpointRef, + pub(super) observed_at: UnixSeconds, + pub(super) records: usize, +} +impl StockHistorySnapshot { + /// Returns the exact selected participant/thread/order scope. + pub const fn scope(&self) -> CausalScope { + self.scope + } + /// Borrows the deterministic local graph classification and exact gaps. + pub const fn analysis(&self) -> &CausalAnalysis { + &self.analysis + } + /// Returns all private-source progress included in this checked snapshot. + pub const fn source_checkpoint(&self) -> StockSourceCheckpointRef { + self.sources + } + /// Returns public-source progress checked for original source existence. + /// This is not current-head or offer actionability permission. + pub const fn listing_checkpoint(&self) -> StockListingCheckpointRef { + self.listings + } + /// Returns the usable clock observation of the final transaction access check. + pub const fn observed_at(&self) -> UnixSeconds { + self.observed_at + } + /// Returns unique known records in the selected order and null quote scopes. + pub const fn known_records(&self) -> usize { + self.records + } +} +impl std::fmt::Debug for StockHistorySnapshot { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("StockHistorySnapshot(<private coverage>)") + } +} +pub(super) struct Prepared { + pub records: BTreeMap<RecordId, DecodedRecord>, + pub analysis: CausalAnalysis, + ancestry: checkpoint::Proof, + public: super::super::public_source::history::Witness, + revision: u64, + known: [u8; 32], + unknown: [u8; 32], +} +fn hash(label: &[u8]) -> Sha256 { + let mut value = Sha256::new(); + value.update(label); + value +} +fn known_hash() -> Sha256 { + hash(b"radroots.seller_stock.causal_known_snapshot.v1\0") +} +fn unknown_hash() -> Sha256 { + hash(b"radroots.seller_stock.causal_unknown_snapshot.v1\0") +} +fn known_row(hash: &mut Sha256, revision: u64, id: RecordId, protected: &[u8]) { + hash.update(revision.to_be_bytes()); + hash.update(id.as_bytes()); + hash.update((protected.len() as u64).to_be_bytes()); + hash.update(protected); +} +fn unknown_row( + hash: &mut Sha256, + revision: u64, + envelope: EnvelopeEventId, + part: u8, + protected: &[u8], +) { + hash.update(revision.to_be_bytes()); + hash.update(envelope.as_bytes()); + hash.update([part]); + hash.update((protected.len() as u64).to_be_bytes()); + hash.update(protected); +} +async fn header_at( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + revision: u64, +) -> Result<record::RetainedHeader, OperationError> { + let id: Vec<u8> = sqlx::query_scalar( + "SELECT envelope_id FROM stock_source_evidence WHERE revision=? AND length(envelope_id)=32", + ) + .bind(revision as i64) + .fetch_optional(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + let envelope = EnvelopeEventId::from_bytes( + id.try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let header = record::read(connection, input, crypto, envelope) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if header.header.revision.get() != revision { + return Err(OperationError::RecoveryRequired); + } + Ok(header) +} +async fn rumor_part( + connection: &mut SqliteConnection, + envelope: EnvelopeEventId, + part: u8, +) -> Result<Option<Vec<u8>>, OperationError> { + sqlx::query_scalar::<_,Option<Vec<u8>>>("SELECT CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_parts WHERE envelope_id=? AND role=2 AND part=?") + .bind(envelope.as_bytes().as_slice()).bind(i64::from(part)).fetch_optional(connection).await.map_err(|_|OperationError::RecoveryRequired)? + .map(|value|value.ok_or(OperationError::RecoveryRequired)).transpose() +} +async fn original_rumor( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + header: &record::Header, + hash: &mut Sha256, +) -> Result<DecodedRumor, OperationError> { + let envelope = header.manifest.envelope; + let piece = header.manifest.pieces[2]; + let mut raw = Zeroizing::new(Vec::new()); + for part in 0..piece.parts { + let protected = rumor_part(connection, envelope, part) + .await? + .ok_or(OperationError::RecoveryRequired)?; + unknown_row(hash, header.revision.get(), envelope, part, &protected); + let clear = crypto + .open_stock_record( + input, + "source_part", + &record::part_id(envelope, 2, part), + &protected, + ) + .await?; + clear.expose_secret(|bytes| { + let length = if part + 1 == piece.parts { + piece.bytes as usize - (usize::from(piece.parts) - 1) * 16 * 1024 + } else { + 16 * 1024 + }; + if bytes.len() != length { + return Err(OperationError::RecoveryRequired); + } + raw.extend_from_slice(bytes); + Ok(()) + })?; + } + let count: i64 = sqlx::query_scalar( + "SELECT count(*) FROM stock_source_parts WHERE envelope_id=? AND role=2", + ) + .bind(envelope.as_bytes().as_slice()) + .fetch_one(connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if count != i64::from(piece.parts) + || raw.len() != piece.bytes as usize + || <[u8; 32]>::from(Sha256::digest(&*raw)) != piece.digest + { + return Err(OperationError::RecoveryRequired); + } + let rumor = DecodedRumor::decode(&raw).map_err(|_| OperationError::RecoveryRequired)?; + if rumor.event_id() != header.manifest.rumor { + return Err(OperationError::RecoveryRequired); + } + Ok(rumor) +} +pub(super) async fn prepare( + connection: &mut SqliteConnection, + input: &AttachmentInput, + crypto: &WorkspaceCrypto, + authority: &Authority, + scope: CausalScope, + listing_minimum: StockListingCheckpointRef, +) -> Result<Prepared, OperationError> { + if scope.seller() != input.participant() { + return Err(OperationError::Unauthorized); + } + let progress = authority + .sources + .ok_or(OperationError::UnsupportedOperation)?; + let revision = progress.revision.get(); + let genesis = StockSourceCheckpointRef::from_host_metadata( + input.authority(), + Sequence::new(0).map_err(|_| OperationError::RecoveryRequired)?, + None, + )?; + let ancestry = checkpoint::authenticate( + connection, + input, + crypto, + progress, + checkpoint::Target::Minimum(genesis), + ) + .await?; + let mut records = BTreeMap::new(); + let mut known = known_hash(); + for revision in 1..=revision { + let retained = header_at(connection, input, crypto, revision).await?; + if let Some(id) = retained.header.manifest.record { + let (raw, protected) = record::canonical(connection, input, crypto, id) + .await? + .ok_or(OperationError::RecoveryRequired)?; + if Some(<[u8; 32]>::from(Sha256::digest(&*raw))) + != retained.header.manifest.canonical_digest + { + return Err(OperationError::RecoveryRequired); + } + known_row(&mut known, revision, id, &protected); + let decoded = radroots_protocol::commerce::decode(&raw) + .map_err(|_| OperationError::RecoveryRequired)?; + if scope.contains(decoded.content()) { + records.insert(id, decoded); + if records.len() > causal::MAX_CAUSAL_RECORDS { + return Err(WorkspaceError::Capacity.into()); + } + } + } + } + let mut wanted: BTreeSet<_> = records + .values() + .flat_map(|record| record.content().header().parents().iter().copied()) + .collect(); + for id in records.keys() { + wanted.remove(&SourceId::from_bytes(id.into_bytes())); + } + let mut external = BTreeSet::new(); + let mut uninterpreted = BTreeSet::new(); + let mut unknown = unknown_hash(); + for revision in 1..=revision { + let retained = header_at(connection, input, crypto, revision).await?; + if let Some(id) = retained.header.manifest.record { + if wanted.contains(&SourceId::from_bytes(id.into_bytes())) { + return Err(OperationError::InvalidEvidence); + } + continue; + } + let rumor = + original_rumor(connection, input, crypto, &retained.header, &mut unknown).await?; + if rumor.author() != scope.buyer() && rumor.author() != scope.seller() { + continue; + } + let source = SourceId::from_bytes(rumor.event_id().into_bytes()); + if rumor.kind() == radroots_protocol::profile::COMMERCE_KIND { + // Unknown content cannot supply trustworthy thread/order semantics. + // Conservatively block this participant pair rather than assuming + // it is unrelated and resurrecting an older actionable record. + uninterpreted.insert(source); + if uninterpreted.len() > causal::MAX_CAUSAL_SOURCES { + return Err(WorkspaceError::Capacity.into()); + } + } else if rumor.kind() == 14 && wanted.contains(&source) { + external.insert(source); + } + } + for source in &external { + wanted.remove(source); + } + let public = super::super::public_source::history::prepare( + connection, + input, + crypto, + authority, + listing_minimum, + &wanted, + ) + .await?; + external.extend(public.present()); + let nodes: Vec<_> = records + .iter() + .map(|(id, record)| CausalRecord::new(*id, record.content())) + .collect(); + let analysis = causal::analyze( + scope, + &nodes, + &external.into_iter().collect::<Vec<_>>(), + &uninterpreted.into_iter().collect::<Vec<_>>(), + ) + .map_err(|error| match error { + causal::CausalError::LimitExceeded => OperationError::Workspace(WorkspaceError::Capacity), + causal::CausalError::InvalidScope => OperationError::InvalidEvidence, + _ => OperationError::RecoveryRequired, + })?; + Ok(Prepared { + records, + analysis, + ancestry, + public, + revision, + known: known.finalize().into(), + unknown: unknown.finalize().into(), + }) +} +impl Prepared { + pub(super) async fn confirm( + &self, + connection: &mut SqliteConnection, + ) -> Result<(), OperationError> { + self.ancestry.confirm(connection).await?; + let mut known = known_hash(); + let mut unknown = unknown_hash(); + for revision in 1..=self.revision { + let row = sqlx::query( + "SELECT envelope_id,record_id FROM stock_source_evidence WHERE revision=?", + ) + .bind(revision as i64) + .fetch_optional(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)? + .ok_or(OperationError::RecoveryRequired)?; + let envelope: Vec<u8> = row + .try_get(0) + .map_err(|_| OperationError::RecoveryRequired)?; + let envelope = EnvelopeEventId::from_bytes( + envelope + .try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let id: Option<Vec<u8>> = row + .try_get(1) + .map_err(|_| OperationError::RecoveryRequired)?; + if let Some(id) = id { + let id = RecordId::from_bytes( + id.try_into() + .map_err(|_| OperationError::RecoveryRequired)?, + ); + let protected:Option<Vec<u8>>=sqlx::query_scalar("SELECT CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_records WHERE record_id=?").bind(id.as_bytes().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.flatten(); + known_row( + &mut known, + revision, + id, + &protected.ok_or(OperationError::RecoveryRequired)?, + ); + } else { + let mut count = 0; + for part in 0..4 { + if let Some(protected) = rumor_part(connection, envelope, part).await? { + unknown_row(&mut unknown, revision, envelope, part, &protected); + count += 1; + } + } + let actual: i64 = sqlx::query_scalar( + "SELECT count(*) FROM stock_source_parts WHERE envelope_id=? AND role=2", + ) + .bind(envelope.as_bytes().as_slice()) + .fetch_one(&mut *connection) + .await + .map_err(|_| OperationError::RecoveryRequired)?; + if count == 0 || count != actual { + return Err(OperationError::RecoveryRequired); + } + } + } + if <[u8; 32]>::from(known.finalize()) != self.known + || <[u8; 32]>::from(unknown.finalize()) != self.unknown + { + return Err(OperationError::RecoveryRequired); + } + self.public.confirm(connection).await + } +} diff --git a/crates/storage_sqlite/src/workspace/stock/source/transaction.rs b/crates/storage_sqlite/src/workspace/stock/source/transaction.rs @@ -66,7 +66,7 @@ impl Access { namespace: &Namespace, clock: &dyn WorkspaceClock, proof: &AttachmentProof, - ) -> Result<(), OperationError> { + ) -> Result<WorkspaceBinding, OperationError> { namespace.validate()?; super::super::unchanged( connection, @@ -101,9 +101,64 @@ impl Access { if !self.record.administrator() { return Err(OperationError::Unauthorized); } - Ok(()) + Ok(current) } } +pub(in crate::workspace) async fn history( + turn: &mut Turn<'_>, + binding: WorkspaceBinding, + minimum: StockSourceCheckpointRef, + listing_minimum: radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + scope: radroots_domain::causal::CausalScope, + proof: AttachmentProof, +) -> Result<StockHistorySnapshot, OperationError> { + let access = access(turn, &binding, minimum, &proof).await?; + if access.authority.catalog != 8 { + return Err(OperationError::UnsupportedOperation); + } + let prepared = super::history::prepare( + turn.connection, + turn.selected, + turn.crypto, + &access.authority, + scope, + listing_minimum, + ) + .await?; + let mut tx = turn + .connection + .begin_with("BEGIN IMMEDIATE") + .await + .map_err(|_| OperationError::StorageFailure)?; + let checked: Result<_, OperationError> = async { + // The complete cryptographic/row witness may span a large local + // history. Check usable current permission/time after that work. + prepared.confirm(&mut tx).await?; + let current = access + .confirm(&mut tx, turn.namespace, turn.clock, &proof) + .await?; + Ok(current.observed_at()) + } + .await; + if tx.rollback().await.is_err() { + *turn.uncertain = true; + return Err(OperationError::RecoveryRequired); + } + let observed_at = checked?; + let private = access + .authority + .sources + .ok_or(OperationError::RecoveryRequired)?; + let public = access + .authority + .public_sources + .ok_or(OperationError::RecoveryRequired)?; + Ok(StockHistorySnapshot { + scope,records:prepared.records.len(),analysis:prepared.analysis,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), + }) +} struct Observation { ancestry: Proof, header: Option<RetainedHeader>, diff --git a/crates/storage_sqlite/src/workspace/worker.rs b/crates/storage_sqlite/src/workspace/worker.rs @@ -38,6 +38,14 @@ 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 { + StockOrderHistory( + Box<WorkspaceBinding>, + radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + radroots_domain::causal::CausalScope, + AttachmentProof, + Reply<stock::StockHistorySnapshot, OperationError>, + ), RetainStockListing( Box<WorkspaceBinding>, radroots_storage::workspace::seller_stock::StockListingCheckpointRef, @@ -218,6 +226,9 @@ enum Job { impl Job { fn reject_recovery(self) { match self { + Self::StockOrderHistory(_, _, _, _, _, reply) => { + let _ = reply.send(Err(OperationError::RecoveryRequired)); + } Self::RetainStockListing(_, _, _, _, reply) => { let _ = reply.send(Err(OperationError::RecoveryRequired)); } @@ -455,6 +466,7 @@ impl Handle { | Job::OptionMapping(..) | Job::RetainStockSource(..) | Job::StockSource(..) + | Job::StockOrderHistory(..) | Job::Revoke(..) | Job::StockAuthority(..) ) @@ -671,6 +683,36 @@ impl Handle { }; let _ = reply.send(result); } + Job::StockOrderHistory( + binding, + minimum, + listings, + scope, + proof, + reply, + ) => { + let result = if kind == Kind::SellerStock { + stock::source::query_history( + &mut stock::inventory::Turn { + connection, + namespace: &namespace, + selected: &input, + crypto: &crypto, + clock: clock.as_ref(), + uncertain: &mut uncertain, + }, + *binding, + minimum, + listings, + scope, + proof, + ) + .await + } else { + Err(OperationError::UnsupportedOperation) + }; + let _ = reply.send(result); + } Job::StockSource(binding, minimum, envelope, proof, reply) => { let result = if kind == Kind::SellerStock { stock::source::query( @@ -1227,6 +1269,25 @@ impl Handle { ))?; result.await.unwrap_or(Ok(anchor)) } + pub(super) async fn stock_order_history( + &self, + binding: WorkspaceBinding, + minimum: radroots_storage::workspace::seller_stock::StockSourceCheckpointRef, + listings: radroots_storage::workspace::seller_stock::StockListingCheckpointRef, + scope: radroots_domain::causal::CausalScope, + proof: AttachmentProof, + ) -> Result<stock::StockHistorySnapshot, OperationError> { + let (reply, result) = oneshot::channel(); + self.send(Job::StockOrderHistory( + Box::new(binding), + minimum, + listings, + scope, + proof, + reply, + ))?; + result.await.map_err(|_| OperationError::RecoveryRequired)? + } pub(super) async fn stock_source( &self, binding: WorkspaceBinding, diff --git a/crates/storage_sqlite/tests/fixtures/stock_history.v1.json b/crates/storage_sqlite/tests/fixtures/stock_history.v1.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "scope": { + "thread": "7171717171717171717171717171717171717171717171717171717171717171", + "order": "7272727272727272727272727272727272727272727272727272727272727272", + "buyer": "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5", + "seller": "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9" + }, + "listing_raw": "{\"id\":\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":100,\"kind\":30402,\"tags\":[[\"d\",\"01010101010101010101010101010101\"],[\"title\",\"Carrot bunch\"],[\"summary\",\"One bunch; CAD 3.25 per bunch\"],[\"published_at\",\"99\"],[\"location\",\"Example region\"],[\"radroots:price_unit\",\"bunch\"],[\"radroots:listing\",\"{\\\"authority\\\":null,\\\"default_option\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"fulfillment\\\":{\\\"area\\\":\\\"Example region\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"modes\\\":[\\\"pickup\\\"]},\\\"media\\\":[],\\\"options\\\":[{\\\"id\\\":\\\"0202020202020202020202020202020202020202020202020202020202020202\\\",\\\"increment\\\":\\\"1\\\",\\\"label\\\":\\\"One bunch\\\",\\\"lead_seconds\\\":\\\"0\\\",\\\"minimum\\\":\\\"1\\\",\\\"price\\\":{\\\"basis\\\":\\\"1\\\",\\\"discount_bps\\\":0,\\\"rate\\\":{\\\"currency\\\":\\\"CAD\\\",\\\"exponent\\\":2,\\\"minor\\\":\\\"325\\\"},\\\"tiers\\\":[],\\\"type\\\":\\\"fixed\\\"},\\\"supply\\\":{\\\"type\\\":\\\"unknown\\\"},\\\"unit\\\":{\\\"contents\\\":{\\\"type\\\":\\\"unspecified\\\"},\\\"label\\\":\\\"bunch\\\",\\\"type\\\":\\\"package\\\"}}],\\\"product\\\":{\\\"description\\\":\\\"Independent public conformance fixture\\\",\\\"name\\\":\\\"Carrots 🥕\\\",\\\"origin_summary\\\":\\\"Example region\\\",\\\"producer\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\"},\\\"profile\\\":\\\"radroots.listing\\\",\\\"state\\\":\\\"active\\\",\\\"version\\\":1}\"],[\"status\",\"active\"],[\"price\",\"3.25\",\"CAD\"]],\"content\":\"Synthetic carrots; availability: active\",\"sig\":\"7ead70c1825f09d2fac04c0501baa4e5d46e0117d8d04b15cb901d663ef425c192a992d595b21dbaf1e73626706314a42111858556c65e27482d2ae7696329b5\"}", + "listing_id": "46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b", + "quote": "ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a", + "request": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4", + "withdrawal": "113eab1ef364f4798df9d434c9d0d45c62179121025b26810b2b3025392d9bd9", + "buyer_fork": "628f182a308bda2eb6f3875563ea56aec82dae4e491cee387f56af573b7893e2", + "decline": "d58afb1c571a5fba2b19caa48ded5b3f0b24b3b67464d7088baf55780522d813", + "missing": "abababababababababababababababababababababababababababababababab", + "producer": { + "library": "nostr-tools@2.23.5", + "curve": "@noble/curves@2.0.1", + "bip340_primary_vector_zero_matched": true, + "script_sha256": "e0fbe3ee194f8e27cdcb1011d16fe48020536d56bd2a5ced11dcf69d1d8c1592", + "package_lock_sha256": "bd23a2b631ddd90c91ce044187e4feaaf27fb1f4590da2e203afc28d8ea6cd22", + "redistribution_provenance_sha256": "145d2cb14377bf67c0e65c452ed07ba10577a1e8ea1db3979d2d2780cb31a7a6", + "record_template_path": "crates/protocol/tests/fixtures/commerce_wire.v1.json", + "record_template_sha256": "0d0342f2de38a7f5b31f9d650d91940a3423b0e10a80eec923fdeb1e7b8aac07", + "public_source_path": "crates/nostr/tests/fixtures/public_heads.v1.json", + "public_source_sha256": "96aef2300e1b6d0b13a4ce60ab3d106c223d08fffa640e43b2598ce2b6c4c7e9", + "synthetic_only": true, + "production_entropy_claimed": false + }, + "sources": [ + { + "name": "chat", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"666879832a53446ded9eee874a20f0a8dbd8aecc3aa827abb2dc700226e498d6\",\"pubkey\":\"609ae8d31e3b290e74483776c1c8dfc2756b87d9635d654eb9e1ca95c228b169\",\"created_at\":1699993999,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"AvtsQj1w6+FNiNZJS1vuRJCStI2GdYaND+0CZwrDu0D2nUnonQgk+bYTCrhXlyIBNDZuE5mgJu16hadaUbzHFPhNP4ZaXfQ6DziWcU/SZPDva9CDVC/6jeJDU5BYkVabiYsXKhjawEyWtTCb1TPYzThEARFgJypPLa9L1lSFePDL0B6yI9enHZhV7EgrYd9haV21kV7ViDLicopliAyWtuOAD0xIuvTK+KUWY1lnCCsSPLzV2amlWFcSYwcBZPaBVEzW47RHxckGuvJGWTou/1j4U2vHAPDAmxDRDo0SK8JSlt+BrkUiJ4nm5fBAfYlX1RvbVC7B1FaxZOIBZOFQeY4utrI0N0SeYa9igrcQtTKc7sSiKoo191t5WxVx/s3ij/gYHIykPpm+iSL+m7vWhL8cpiTLqpB4gptTVBgQEvhO7FnxT/CkxpIn0fDsUdIOv2HzoZV51j5a/fiUZAw5UikNNrD5lDGr8mKN7K4K9NWqmp3PeJ22M94hr2pnHlZYChqEQVNl8+KwVrrGO3JY6xUZ9abu1a6s2roO16zekjP3Q1plHvDgh4mmVuPz/+SE2JWKi6wvKor9xZKXM7Zo/hwzucvEfOnwb8cdMHlb3V4Flz8qxdxKL6IMYl2AjYTVRrTEPdBHPwtvdHwzuNgLGPmRMdGkoQKIn+q/Ozwrn5omR6fFXm7+2x0DWliRPcJEYY+sw87NVIfWdH6IYjuSoUZghzvj/xTLoXzizZOQ1jZUbXmBCKQOSjxbFwTeAGL9Dg93ODm+y0yNC/wn+gbThBDklzEp8R7RwX9nXpQ6pD2tVohwMfF5/dfsTLzQMPNO39NxAA6tAeYXJTEqLzduu+IkH2oBbuICtPCLHThXkHfpPP9ZWs1S11aVKwa2C0x36cuhCH1+O2Epj2JP9R5R3ueFWlMfnsImWvEvUFIIWR6GkxAjtsklguX7yGd2ayrqS8cq7OMovZ/yoZQHekSMK52M14DbjPwlqND85i4dIdCG5dFKL/jt75rBb8oIZo4PdCXDjjT/+z15ZJJRXWTo0L5wwWs33I3M0z4CVuttvU1x1S2SlOVrmsoth3G3dAth2fIZBpu0obFIa/SIb8Mfjvor5ak9DngqZuxjHQKAODsrDNtPp6ElAbrvneuMKz36z6yB9oOqGPlQ9/WDWKwoO8jG1g3YAzLZfvCdErCC1Y4RR1tz76Mc9lG/X8+MB9o4cIY7VySEpEzDw4uPgF18RkzdtQ1/QlfivxSrn5YkBqqH1dyYBMYfM3nn7wG2m2MuJJ0L\",\"sig\":\"93c75b35253544bd906121717e55212eff23ed1ba974bfa2dcecba691e59f73955bd525b084ade827f7dd7d3bba0da2f6f483a847f82dc5a208a901c5f532c38\"}", + "raw_seal": "{\"id\":\"5d9acde162186e8fe12a7b6d231105022a3c5e738c559fb2a4c50b09bce31a1c\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699995000,\"kind\":13,\"tags\":[],\"content\":\"ArJSyqyhXXntS/d1GY4Sd7Fqcl13Qg4Vcj13RR5blj2RW82o6CDBmXkOQtWJA+PVsV75B52AiHGugbydJGd/W5ns20d7T8c39YJLSesPDum6yGTWBqf9tCCF1tjhC/pChGucLy1ufpNcbi39qEKwJjifK+WV+K5P0m4HwbrdJOCpa5NUfBpstcS+ojp5Bt1e+TJHRq8TiV8/K2jdpC3GMwD7BlAQW13Reb2462lQOmFJnSo7EaPA2OkJunmyxFggGJfg1y3G1UieZpJYwGyu5WQ+qQoqv/141rF49y72ELpnihFVkjp+YXz9+/hUFIxKLoPETDWoaFrRB3P+AOoSnC2hrPy604Nth+fx7CO/LAGLNjVTu2YZWnnAGuTBK8+4AaykiJXKdWWYj/uavfPoApTV5xtEthgnGzmw2M9dgr/fX6TCJzca9ErLo0ZLbVU/9sV9E19eH3HOr9H1KX411WnSU72VrMxbbRdNIv/596E25DkVSuFK7+ckWnRQNXTqS/Hy\",\"sig\":\"d9a35f12946f0c907e6039fe51322b893b49b623be1f079d6964c12472b779ccc723611e395ff81c393ce3eb638ca29a3fd3db23ef7b6bf784862ffbfb17f3a8\"}", + "raw_rumor": "{\"id\":\"93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":102,\"kind\":14,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"Independent private question\"}", + "rumor_id": "93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0", + "record_id": null + }, + { + "name": "quote", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"967260e452f4fb2ff723585b630f09d4aeacf7a5c6dc9a95248e9a9d709143a6\",\"pubkey\":\"27510ef82e4b2134180855bf0469d1f0f89b9afd573f27814a1bea509db7ecb7\",\"created_at\":1699993998,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"a41ff4e0c9937ccf3dbdf71a654531db8ee8550e6cb81ec6aaee95728447a42d75a7f334d80ffa54ce4f31d2aa094c38c59f9a7d370c3249c91c98ed985b10f0\"}", + "raw_seal": "{\"id\":\"1feab298d9fe39e3edc2d8e72eca407f55e4a103c57e97f38bd0e4c9aaca0f69\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":1699994999,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"e64a9dd82e7b5af781de41ce997535ccebb4e798ac2fc1e5a320c8bfd057a959e9df18b29cd62adfee4b9fe39e223eac947aa60c0593230c92a0eb1e4838b367\"}", + "raw_rumor": "{\"id\":\"a8004b5c71fe824c85fa4c68f53ba930658b4a531807dbf813baf9ad66336b81\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":100,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"100\\\",\\\"order_id\\\":null,\\\"parents\\\":[\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\",\\\"93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"250\\\",\\\"in_reply_to\\\":\\\"93db9283e74810d82f91c91d809e062838468c7884c95b027e52af715df1e8f0\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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}\"}", + "rumor_id": "a8004b5c71fe824c85fa4c68f53ba930658b4a531807dbf813baf9ad66336b81", + "record_id": "ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a" + }, + { + "name": "request", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"5c2c1f608a3c97677df435ddb862253a8bf4b3f311ef8e83ad86aa8e5d432e05\",\"pubkey\":\"f16e7c7f134e0488b8fcea4c926b18a6a6a839af526eb5aa5163b57e0a01b39c\",\"created_at\":1699993997,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"92571039fe39f6ea248b33847439d7dc236f8038a7a1d9ceeb43402ccb097406c61787cfd92cf5645b27e6c1afb8d1ec8f52af6535a09e56f2408e21f41520a2\"}", + "raw_seal": "{\"id\":\"2c44aaeac89bdd311219641808d7a0b52ae82355a560a9ecdb0b34c06589dca4\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994998,\"kind\":13,\"tags\":[],\"content\":\"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\",\"sig\":\"d44a9f62325d71d7028535361553496aa80dbb4651362dd63636fcb881bda2c69e0b8ee7306aba8bde51bd3269a4af7e0810e20e0699f7216a55963a9077eef5\"}", + "raw_rumor": "{\"id\":\"18c1e8d91f002c999ef14227dc757aaf6c3fa088d7bd3d956dd15d16168d0227\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"101\\\",\\\"order_id\\\":\\\"7272727272727272727272727272727272727272727272727272727272727272\\\",\\\"parents\\\":[\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\",\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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}\"}", + "rumor_id": "18c1e8d91f002c999ef14227dc757aaf6c3fa088d7bd3d956dd15d16168d0227", + "record_id": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4" + }, + { + "name": "request_rewrapped", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"c823c3fd4574a22dd1f5d53ff3c854514ba124fdacd46895ed74c445dfb684e6\",\"pubkey\":\"773ff5a8d388277b7921405c99c9c207f4a6c2ee3b59ac1d7452c8ca4db16d3a\",\"created_at\":1699993996,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"AqCtH6Yrnx1g5WX8B745mH1SpBP5rGOlGEgb+ruiM5DCerqvFYvHKTbZrBtURXFp7HJHH7vF/uovMxjS3twzj49Q7dgLf8AAAM4nWtvc8ltI9s/g2GcspqaVW+q/QKlphiHl57s/vbWZloft6GWjRsypMnP7l2z7v8nbAqlbmjN9kkMjjjfnnjC8rZlj0td9pjs97NjUu5BKUAECLUNqzimj/JSjceRTHSgDvLMbK80UykpJcpAsG2MmaZ4jH5APv+aNmS3/VV9MiVaJLHEd2lGPs0p1Q4+6DsNBBOSamngVpMOeJpkXeRah5kGcGrzmEt7qS/8LvD6DHaJ7qwarkMLKWgh/46SxEWnSsyLQr4fbZyb1nK1Gzw0CsuMv51W3EHm/xNYfubzm0Oxd61m/X7sqBS18JP+/5M8tU4nk9Oskw6TnMEN6qMjMKJqtNgRrxGCcRUVwRwIhU9w3QAc3zSpYupgPgwlwh6bv6aoLpIuik7GYMg0hXxfNoQl9gvcMqPbkd63obSBkVyruFejX2z3zKsimqxzVckl2lEvGbKP8BzY5FU34KjC9DfYA4mhLGFUaIlmAqzZVGF5PDHvZHPrA7P4Og4lRpklI51N4SSqmoK6IFZ+bLZZDTC9c38Kw9IYrxpsoF1DOoXwUNqicOmgs+sj1v9anBv4g5l5OgQiUkMB8CZTetRAl2wA/1AO41e21xvZr35n0B5LQsvNAdQ8aAnuE+dJmz1Ljm4vP581/Uhnx5s16t+uO89KLKiLgrFM0dju3kmXTig+6DxbZ3jp9RA9bTc83I5bDlXedXnoEnM7puV+SSiHsKjF7e8hGPaogQDWVUmQnxMi6USwakuDWmpCxUMbAnND3JYiUwBgEheBNvuzWvN713h6juYjf5vjYhWto8AFIlxxIcKaF/zonC0eRynF2w8odLCc7GEJLJc/E2hhBzt1H5tiAyix0Cz/2Nketfvagq/30TzrolJcuGJukCP3s7r+ZQa9MUFaPFU5VcuDl5uSq+3Mq4ruaBzxsKhrkygAVg6BNS7gYbVzmV36d+HTtj/rzAsrEMrJryZRWqQK27N1Kt5RFT8f/qWd3uRMC+jZsOa7ePWPDyv2xQENY4cCocboQKv4qKZ5qyOmBpMMwYsx+4XnPs19dXwR3nhKFU+f3+UsvgcEBTo/XLtkOSNLCXexX1xNumHUvHbsB00vsZJPfcntcQeCFTRDrmLttOXoOyBnnkGlyNyONsNq6rMhM4AEpAHhE5saL93hwhVt4TcijCJM4Duu+wyvnhsTr43QDOtl1PmqLbFIF+sgpOrl1rbUGurQhisa/zdv+kWH2qdLIIaZbVWFsu1Hehbd3nALu0ZHk+syYNLTEjmVOJ5YkjNYGg2UEyG0jMR+IO7fIYfGzn87+466MB9LpEgwHn0Mdd9uTnlkdwO0vBfp11+NCuJes+QULCdJGs45A4zllqp23hQityLrKC1oZ2TAd53e2Ww93jN5qitlJGp/FHt451ZMigQ69OuJd/yApyDTmjBVpGpPM5CKvYgbQBZIvS8aZWhnvZbY9R6h2FIdUJ/DcnTxOG1PQzPMguchTtHwT4dSrA4dWUqd+Srx2MnRHPjWVNsjCmx9En3KVx4mKJZmuzIRScg945HipptMu1ai0FrsTPoR9i3AL/InFn/NxpPeD0sTpsxdsNgAsy2BmdtE2AFRqT7Psey9D5hsDQA+fZzz2M3Ceyx7FyLl0m2S9MVO6YnQFUzqOOjiCmvvwE35oMfoxCNO+hvln+3F/kPNkKQYidKKVwm88ZMdaZdBHX1b/0dt2xb0Hw6Em6yw7Q5EgmglZocg4yCLNORb9qddkU1YrLMaq16DaHB/ZcL7leWKHiOhaUmMrhzGJSls6znoRdPMTuQAOWIHFOsa7RBvnlCW8OaeGOSCWZwIHBVaD14KWBtasQAdLjR3+uepvIUWme+PMuyjgbVAwdQ9z/U/Q+q0yVqY85ekuPLS6Nz39ivTS1xwX+DKhtFLr6/7nt+PJxxvlEKqP9nIcgnG3CRTLtISy2jxqcZGsDhcmT7CTCY4dJmgtL5lGDrPN9NOXOQZOuBwf9dQgOXqbOOwFIolr7FxN+lpeMC/HuxpRa3wtdx1C7WxuMX4QcwbafnUV7LM82f5xRtTdF1FpHQs+w5vH61WzWWoNg0fGR4MYys83Fwlkjrw0CJljgsiPoHfTGDWv5LdTpp1vbbT9vDqeoV8cHhu4baKILezB1Y3AnD7VJ5cfgrkYmpox9cN/wKInPDSRHJhrf7JkBs4zgzqmAL8bpj5mkp34r9vf1A/8HNTAxEb1mCb3fmF4Xlv3qRFeE8mimra3apOO1TKrP07iUMPLrgzxfXyrruw7ciRntPcfvWFpOaX4ElbSOjCcO6eLY159kdQWwE1zt2E1rpiNk6yrNHkR7vFfqi+O/TuN49AMKRgjZzK5LHDcFzsuA1yQ1vg7NZNnjIS01Bjm5iNQpk/qCwv8yAcjwBidm305I4jHZ4BA1yca7LqwBqkk1RLW9Lfc6ytU4ym/OpoMiYEhPaBXButwaFyDRhK/Vs4ETtLuViTriwDMpf4e4B1Ats5V1ocSpvKt34t4TxZpOnmU9nFiXlb/neADAv5/IIMexuwNebr2+6SHk0VmdkRL/1l+F46Rdh+eLvweU7XcT+rErjcZiY8kMmCaB1Cw2fkjQ7LPeAgiKyBVcLcXXnPB/EYL0IzZlORvhGjoRPagYZ+tMHmljtldFN04HyV5ug0Gkfpk4LfA0BuNjzKBsjCd0gr/7bcKG6WP8eXFZXWSCGkB1WB68hNzm1KzhpOk0Y3Qryq3VY1LkpV6BjaLXPs9XXP8GNOyjN898mcq2JujLPLhU5ESSML0qjiybShfILngBCu/KObIJ7CizVWOPYhvVgJUEf8/0vU5F2FhbRXBYcs0eLFFdaNRL63ST/PL6YKOg6ut0Y/PU9nOFwwJ5qy/YDmyPXU+46p2Dnoy4hQsMJpvwR0cYYzxYXYLrHxQa88xXHamOpFi19ZIJE/nF5lJ1YmG3DE1Q0NZjWp5F5W8ab43TpbI4QAwVTGKVR4Qn+BvHNklJVvJQEV6HmANQclPMxHLlyxUtBWDBepD+hg9VzTMxZTeVfBy7JFb340vOhgHizxYUAsY5TJIHd4DoJuP67zyHBbHxTCYYS2eUQuUBz3PtH2hVdWVC6Ko5unrmlolaCSoWO54oGkM+yvaLfRsLISxzkoC1pL0WOh+Xv+CKM3/tVMyteZ07jig9JCMZTI3B6ZArW9W+il4ftEIguXiqz4jpgx6Xf6zWY4lVDlf/7xwJ9OYUXLZfLepXS+6LiuHvcK3qNV8kb76Ve9Z4M5qcsLMz/8PAJ81hPzVImx7y2fLFvU9lEPzk/K+k8AcWSzOibn94gwjAsoxhi1294kGgvz+5+iSwIkpcTDYbgE+ltOYq8tyOGuOmWhUcfiguqjbEKWVsA5eYnZ2jga08FceRru+CdFyl4AZiiyKjVghufevROughaPG+uWRDrxZ1/iLolsTuBBIyFfO9sGWJvj92RbpgwpOEtqW66TpJSjuTf1/Dv4pzM/ccXG+4ZZcSIM99SwCeJFQ8K3Ho+C0MjyZU1w7kXHnFTDeih4rr2ieM9jDvAmd0xeYKuy6DZPBaKCL8oBSobnGO0YZ3PpMxXkz69vGeo/Ataj1pxMUoVwC4u8Ib8gcDV333Q5zrXeYxp0tqriioUJDIaPIlsrRrnvyv88voe5vroLaiHYBCzP9FcEitzEKFsjF6YGsCd3mSsDapb7V3hV6nBVn5jvWqlwdjP8SCpzL6VuYX/ZHjk2Wgiiov4MBIylOGCVzMrpaGdH5d2CPXWN2N+DodbdXsnaKMcfg2CJEqQ9RNPEsP+K1BhVOlDP3w0tXT/cJylHdu0+Xdkvj5MKdGJjfYZr3bw5BBIJduAV/gFY+J0NkJhFwGjSxfzNE4rxltX5oDW3ZNqAb0IzNwN+zXhHlvAI5IuqR7PEWToF6AN/HtcB5yOm/RvIOYn3OcIPpqGPl07TdAqfQVy7dU+LzH7N1zSvE8cn1Wu0H8EqLz996NcdaIUaqaxoBYOHBJMcdvEKzeEpZ4D749xgD3rCIqaY1q55ke2/gPvgGQlQcNOKfSV2FNE/aBBOiYd3l63vU+t2g90TeNt/pYE4uCmdVf2DDZtBd1YrEfY/kth479nN140SQo2+Rco7sILRSmsLI1+D5CwCWn4lqx6+patL5+Tn8gulSX2ZNwVd9pNn/9emLsOWitSpecLNYIx4hsYjyfQIqDodXJnwntDHt+P0m2ew+wfLejvMtqqEzGnmQjI4Sqp6BfKbtg2QwnwsPnkRMMi/eTmBBwEWJNZE604fJGlKAHNsQQzHLRvhsHT9nRuvs2Vkz0LZJ+B8D1jmwPqQkJvLKLXUu2D2Uq0DYu5XcA/A2POWGujf4BJpzB91A/4Bq+M75RjtSdcODjFx/tkxvhHH+lviWBjk5RdlJCzhGXuu7izbkXegSMoCuwciSBvPWFw+9P0O4ibrEYBcdytCtICUHW/au1oN+4ZJCqD2XllrRpkabZR5jJZwVhArWoaL9cB47RuDs9BFhqzlsnECqcDZMCbe4VSSRZn73+c0CWrXdNi14RQJldqCyAyr3UuARwecfbHkAqitoaaaeya7ghslyEQAdGlRuOP5UDGKIdILnYJhYj78lLdqB5uHA9f8csnkUch2OTWye4iFV3kExZgn7DDaTHJ8lKMfBtXc0vU7O0Z4G7FURGXhBHImWDVeOJ3VxP77t+DIWJlVtr/+AQPfLKizagyh5upSNFc91+OpxIJfY/lfSzc1nYwOAmaZjL7zMuKXq3ywQYVeElgUUGxXBwxaHdIfrEe+BLwbtat/dN3BH98+dQrkhS9tsbgHpFrw5yokRwPInacGgDQlOtqB3r7IJiMeb3ReC9oj83o+ksaFPemnJePCEs71sUPp6c1jsM25JryYcTyY5JXIeqtIktXE4ECT8h9fX0FjZGLMiZenvEBozSkaIMSxD4U/mGIZCqrHfai7vjGa3oemvyLLihqusHLAXFBMWFNrWrOhSQCvOg/9HMUf6RI5ZsQRHeOVAmMsXEZEeNfsT+MvoFR+KEo2YCRqDTW0a2R7q5O6OQs/QAMNI/hNAIdD7lqdbXqp36Bw193jdsHi+3XvtjgLk8Ut4OW/EUXnVn4a8Y79PipaS1QzlOz0CFEEc5Tb4Ut10eUTYp24SGtskjxbts/0oSOQsoY99SsxUn1zkO/xox9Z7g8w6irxiLjjnO4ZeVAcwlOMP514QxbYNQLXdPcAfC1wgDEZEOhr9xGT354waUfQ+Fwj8GbhviWPZjq3PQe49QrAxy2ZT/A05WiQT9ajNt0/lJNcXRqAQhvkAHYEQ62QjDelzVoJUMBbLYs6a7mYwfZFog4EzP6z4zwGELWkQbIdw20x02SkX8gca7rOE4ssFAmQZNKCYj05g1b3rSva1aQRQuHhRXvpsZROxZXQI+Hp8MfhKY732RUvtYtJOrUcytmFiH/poic2dJkfsFwe4j8kQNEZeVRVq8pP+fPDxuGlCelHAzxGF7siFzqettnpC4O8/x4W9qm1np6lhHJU1UlLAqJ5vDewbmCLy3APSoYtdCQqNkQQ4MWY0t6+tplCNNGWWQXtmmLoLCFGr3Xbfgrfb6A23F5FD4mmXBFpIE9CaMsVB1i8B96p1L+dNIkXpImeEh0s6128Fwp27nBg8bKfckm5wQOph+aYBQIBn4QVn6t9tBvIN0BwZB3+ZhaR9ihcowMuDjXrSav89ZsJnkAOxSdDnJfRrwQ6BkBNO1TXOcFq5ZSD7wFpzpuix9bFM34cN8Ny5/r7dizMT/sZVgmfr2CLWW6qY7xsUf3CCqzqygkla351jaFPdGE3WWM58iHZYNEn85BeX9RR5ZNE1QmqsOjpW//DyyPsr+0Gw6BwKkqlyn7IAPNBcBNR/XV5VaqHBGJ6iWa9T6OA9B+mFLkM8Hz5ljD2S4qPMDEQ5zoBfQ/EqOd5W2JtVsMpELmJdMzw2rSlGI6g/Z8841/zk+mjFwszBU1KCAiiC7KfiFoimLksy9xg+PrqWdvpwySMhIHyZOPJToF6MqnDETGiWqTMcEUPNURvAxM5/NmJoT6h9MLFKuTQ4xGd6uwPRNJYCOMezD9gMUvljT2XaOygtF6swhgbFeXyodwDi5mq+ty7AQZ/Ewqient9IxfoYjTqVcpRJPJZjvQPL8ho9bkoh/lMtn+iFA99+VBqRMWvzLHMWp3S+TQA5osb7o7R+Zcx2Qw4AmCVsAa401q+SC2rZ2bk2EVdZraJZcq+9pCLxleFcpGMB4aS/aVRwvfnZZje9HiaREHXDpPethXyTSaZokk/D6ef+Ri4guxl3dEqAEg0r3uztc7zHGhhAdFUn68cEbYj4laGnP4F5Nu8ysQw9R0qeIGLGX0wKYJ1AGpoEGbqY03ciRRtB0dNe00ofK0dquopOrdr9OkZCzOiJIaL0pPYBRu9oAbVVBvBTlJ9CYdJPacvT+P5lj/17EHR2cmhB+6cSfHZ/C35YHzgoPpqv8Ffw/Lyu6O8se9eHsPflP+JDoD1LQ376gj6SqE3idIAhZYrAwJ7iZC/y6Pb25rKaE6bOIzCuK23a89Nx4yyD1ATB888udeQYhv11cEXVOklH8L5zekzhsDt9E4ws1yoAaw8C4xVhM5TjVt5qUx+DSN7WQQSW0sfM0/Af6WqLytAiJmhfGDBHWm6xnHDNYwKW8h6dywG8uFcJz9TISeZBFQ9mzkLkZpb0IhL1/Ry212SDy9/RmvyZB5gkLTibrY0y8CFE35fPhgFlWSO2XXSrBnaPUMsmO4p8Vc4VxBrA0V7+DRquN/0xXvWAeFQis/G6Y07qvorkcR3lpAQ3Vn/E+DOJ04zCd+iCfUmAAdB8q5QzFhjmpbBNSWvw/9wMOBpTnVLxHkQuZTvrkzp0HFpFHnfZQf0Jc5YkckxyHNkBJKgB2I7V+wIV1jHs+twTXLhJpN5wtPGgbn+I0b8EjCV8839MfH413YpXo1G2qky8xuBZF1EKrJhPxpyP8TrO5D2vKwcgBZ7gEof3W5eZj5iu6MoVG+ZLaVSURrtd253HjoTAeHjLUD+K9jjS8zhCF3btPgesa0h7pnFe4N8VFBrUBXfrK2bJTg/3gC8KWya5cqK3LDWPPp3SRD2V4mcYCswFZyadw+ulijop+0KI78uW+GG4BSCg5kUSGIwou36OBLLXsxuhpR3QobkLRzQQuOrRdkPz6ZoHz9D/It3vtTf/NFZDgvce/OyNOXWPhN+9I/EjrLv+RsoJqDhE92ljRKDmGUN/SCAf3yrP7GYCzQ1jrYF54B5rEEktgcGYj9OBJClo4tCGOY5OxvToGAnFWuPU2asVtlYMFaf8GoZrttNbjRfF+jpiEVBv3e3COz+sRP0tosD4Zia0lYW/pYULf8gwasDV/vujAMlOX3WpgdYp5iAwJFK+1bfhJ4cX5CaObnvWNfWYRisJnEGui/rynwZmNXX/6qxxuJACxF405zprcDWZ0FGQIbnBVrM+7JGDwH+LH7rJakOUWyqo/z81nj4gjfSaGLKih6E1N5J6pPG75Rk8ezkjGjzvJoTaRTmQGTbdXoOADxW54Qb2mEVyaAgM6EV5L4uRhNAGEIT9AEJ57aKDvNuw6VNZFGgkss4A1aBzma4LdYeUsyjcIsX3wLNb6xryhCdPGF47ULsWE7IQ730SNmlr7h3Yj3tvQ2c+9MBApjhYjWr7EzimmyPIwWYQdlr6Xe24qO/FgSuWA5Lp6u1HlV6eZA57CgCv36k1azUGOvCBMLFSCcNpNodpppERqzVIK1Wli/qxF4WooPXWcFwq09wA6Ellx/iArXn4fjaGqcc91GxhxxMGI2/6UMIWDKAaL0ZOG1OTwGgRheCH4FPoJXcN6l7gaLam0sQ50nZJw4BjmfxNDqbCBTta/dTnT5MrrMkQVUkDVwj+F2eillQv5pQ/NvLcm5m4ik0k4001oEfk6F2CwWl9cPfYU8LZqd12NB7lpyiUQm66XE9xWuwMqU2pzIigr9vs+QBG6qDOkPPF/sIBqSt7ERmcZcpQC4LXbl52IYE7JF6s17QB8MMTCzO8fV6QRFEbw2sY7IBoPgDoejGgVJ4QcsmD0NcO69Z+Mn36IkPqYCaWtQn48147BXqhuDtaZFQ8MzqCAlcXIVofA4GzgmIkdYrp5rvTrxfrml6Gvn4QEy+IqxXGJTVEUTgSjJJHKRbJJZffrRARyfqKcw==\",\"sig\":\"33ac1f3b846c9594b9117c949393729f6e8ea37271da95cff2a0bea29e17ada17613a6308fbc3aacab33fc6da86ac2cc07de33c4bc7f1d4947d488a2329cc37b\"}", + "raw_seal": "{\"id\":\"9bf8252c78ccf8292347ea545eb91549ccca12135ab99f6e97ae093c0c0802f3\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994997,\"kind\":13,\"tags\":[],\"content\":\"AjdR4NJ2EnKiQl1Nw76+0o1vbhClPsFcCuqWl53owPUgxGKYo+97fBW3yG4j7fDPVZhqpqft0PvqT8woIin6Pj8ZcIsdPscLW+TekjPRbFw6xVEK8gV/pfJoJsqP7mBMLK6/3OCAGhX5PRDAYJDHeYoZnZ5l4hn5WWX4KVRsg4aDT99hVfHMhByfUwDfzDasKdYwqrLRV0QRpjBubwBscWMfIwil7EvVG5vj43W8ZoyT7uBj1zf5nbjls8B7GYBYLDXH0iVMxFHaSTFQexm8oyI5FD6AlKzfAhPzRIzJUk0j6O++LfuMwI0tHF++DhYFubDGFWFxKa2NWzlzbGzu1oITDmjFXxncfsuuhCK44IyWewUckRcN+FIu0/yGOAVVNG4RDwQ927cudIcLzftllVyAsDsBh7FuvBjaQrf0WFihkop/5z7NoV8P41QlVuUREZF+hs8ETHDnz2o9XKhgflgo8kjO/6Tpmj5x8udDVVHZMT1TChAf/4wEHIhTUcdum1m/TMKzXv1W0026m6gPxOwiOndwK/CiuQDpnXeWz8pFT8MHDcbBh0jFi/YTTqWmlviarQjqDwDOfgrGLro1djARNnyfp4W00l6QLefsSyRMeB2L+Il1tGImZoBywr37DFTnVWxMlTSWBSGBALDUr5ZJdF1YkBoiZWZKIj5f0bvjQ5lNZpdk9J3rKpVMPEEu2l9vi+lp1ynPE4BQok88/e5sEtEVe3KHktx+5ntKig5MFAks6iJjya1XBOKLylVY/nUcHLsf9vL9WUSzu55ZZCduFR/0zGst6IlugUaTV2vjaqgnSeVqQv+zYZHCYC6K3py1OasNF9jal8sg8/JPAidV/4gYCcsHT/zvSa0430fG9sXsEkcMzzGFxvOZyKOpg+nktojfELVR/4B1mefSsGveoNPoqPQyc4MP9285aAQ4PI3Dgqx9XUPNZoPQB7MEuUzl0hRCDrDVCyYfvGNAi+Ozgsvw4/oDhCR92Ra5xjcWGNURGG2GZgC4ZEH4/BhALpyE0enmdu0yeATVuTXI8ibVno6z2krtnUWOt/U0SNKP4V4D4Ee5NiUlgJpr4X3QwT5lSHPvYnIghbVg/qwfKFBpD0iN0De1V+C6c0PB+MzpgZe3Qk3h4yZXpo+qG+n9AnNhOhxh8Js/PRRJ+eUy7Y1LudyXDmV2vF1mUzycQDkG1EJqkCzJBDV3tEBLYts+AzVdFou9YtZ7aAuc/reSzENQAB6uKIukQvhPfU7G6MA1TJ+Zso9cUy47D+RTXX1Z4NzdMezitpijbx545VLZUQqq1ALWKC6GhJDiAJtl4bo0arhc3xTlNhDKRlWChOnJje0HGBectxm3JqRlOMCQ4/djq8T6u1j8gWfYkUSKkasDb8yZIVXNp8yBcvMP7XII+QEENxgpr2LQaeji4NhLoIhf/gk17hzMoTuhYfVKiBR9DN8PSI3uzvo5NUNCXrzX1OrUKjugg4Ui9gk2xKjCE7ukP+a2KlsYHdY5IbwparlHM9t7GCfPOyo/UN4kxZfiACB4L4k4DbG8+KLnftqAen7RlElSE/L1mxx9Jt5Sgwyy50FjCOQvduim4kEZhV/2TbxMyoCbe52kQqttyu/RAOXFMDBPr6qjwy8TPzsFjK49yJSxGFsii3iDFkDQVhiIshc8hCKyLZt8P3FqpXobVAsUh8m8PSjnUR0L9VxBjRuCqlzvM/LPIkh9orhhD07irdnQCzX6lK0oEi/3YkU/bRlPXc6qg0a01wx/Osm7ltXp/sPHYygojOcoKa8UQ8jpj1L9fwYaGn+ccEFmOHBgiCUCIIOAeT3FFz+cdMqPBU618GuBEQm+IGQp+WaV2tN6884xKSVoJmJtrwIo449niLndCUjrtLjPL9RTs5I6dggna2ICGYb45uTCycPsdyQQ7YoGPXoi9CcKV3Rl75LT2iwUwlF/phiFibwo1JYPHYbHCiIudLnAhSbCpkpLTkMvMo9ZT48uiV20x0FIrf6wDUYX0wQNsijTaE23/kldDeOfCtCzg4dsiBPsqB+QGZl0bxVSMjvvG6J+M3PzUmH2IKF4G6UxujjLilKvGm55kQe/A6TBJOOu5e+VGGT7z+60xFrZieXS5JovWv5zyv86XK/Kup/cYmTS9egkdVgW77mrb28mVtP1a79JbFpq2ELny7OLjdfK3SJNdjCq2Jn6arJUqjlSw1zlzwhvHXgWuWbZRFM9bG96MCmiraAgpMQcXvCLlSt0Lxd20Od2kDlF1vQZvT93+pw5d2YYzQSTE2TCFIqgfDSQ2xstCgHGNMuCFLHhHPPX8IvH85ib81M/4c9bTqype4oUI+nC2N60hlGJqifwLYRFcwJHQKy8W2mRXCHsxVNFYkBFb4aC+IEciEZaoqNf1DO1gFWsMd2DouOAEV0VfqGOw1yTNC1FXL12HYZGF/PeLax1rkhqGnPXsXhKmvnVw1YrWeae9B6wAntxMnCRvqeDYusTfZYtUZvuLSIneJG1w4clOK1WvkAazofiOETdouD58htsjSsQqKrKERlDQvEWeGsumZd1c8JJPrexCq6LQ3kuKSbA8vvovuOBYBSCbcmpcbyDgJ8JqIEyW66fZRQNaBERQLAgg5uaRoXfnzFvBFMW9sqSEkVVFmwlmSOWmBf7XNkmPIKwZ1033qVABf7ctrsKlCaF0ppAEly1V144bMYWe5+GKV14y8Ew//8TIMAsYC+Urssp5kaZb88ZFRKImpp669L2kkI/oaLyaIwqcQPGekT9f+VHyazdSKj+8VlO4M8ItGc/M3RR7RcRp8LHf4JC70IYOg3Ek+vX2XIUOM9j+pAY2LxvaKKggsg2sXHFZKx8sXFu6AhdAvTHvgOV1Jrh9ftgEzwpjutj5hSuRuoayVlP49QKK8YU5NlIne1LdYO4yfuRi207oJ2+I2N3iNpFTPsO0gPtwml43EwTJ2OnyMiiGVlPq0wETcV48Bno9g5cd84W2ODt02m1S/W7uA5GDPZchsuT+dCfsAEdFnDw1a27ioxqGK+5pw6f7MhGpt8INhHECZ9spOd6ut129ohuuNTetPjVQaXwoOIUx334opUG57L9erx+yYtmofEzdo1+G5FRshoIA63KHeNTyI6CYIhovvbEiYqI/Ogrmn+2y3X8TVGbAUxbP7TG8G6crqlfePh3rDgU9S04ykS/dHOQm8og4M4m81Lz4ofkGDPEOYlZNDgmwODU4aW7fFgCCdl2maJHRW6vHaauAdRMc+4ZjxgRXmTvYqO4TAFHSsxHnCW4S/CQbL5A2cO9+QHZnLiAvC652skuZ6s1isWt0BnoQtDybd60Zbv15jblKCYvJgLYFiUh6JqzLK2tUuoO5cmT3zlhfsimJrtJSjzazlRXyaVT0PWa81KTc6GofatbFv5VbD0c4/3Ts7KCNeXSXNoBt+kT6tR8s+RlswagO547tbO5cPVn1ePG3BXK4VYJdl0oy5oLUx2rMDrqnQIgl5sKydAn3Qsvdm5UHJ1xKTAFPlHNr7Go2GHSZigk/kaoxVLL+c6xhSN1QtPiVIh3v9WlZmdmdWsbvBQZZKfeGK8ZHWpNWON/O+gyNuedxXcB7/C+As6g7SaCzf+IxRsKDKwVDsvfMUVjHjWYtS8LJz3ufA9fjhBJJmQtWau/a1+SwClz92cXRqd8mdkzN+F93jN97ZerseEv9SmlDoPRFfdNlkwow3M0Y0VxfIdnegv59DJSTgh0dOra+vtTa0yn5SZmD6hDROnkyvK5p2nRfM6kYk8GtNzu2SfVZCozCvduYlRF/kwc15cPptHt5EfryE9U/aco2lJ/5KJ0g/JjFKyAdQdfI3K6nSnK/wiD1+7T8OvvXR55Je6IoJFyc7Q/mc0rgU97PNiXlSyicuiO1tG5AgJwerSGb5LgZb9GJ8XzQn1AY3u+B+ejerkmR5aQDBx31lcgE+/sTVTqeGKvArPc5NuejQn/ws8mF5ll/iSWtHsbBJLqLLZxywS1yCNhn+bq0ts+lSlvNCpOtJpBQAZ7qQ+OHGvEoWoblYU9xGIYY1JA9T4G2XrQ2lqS7mTPafKYoKPM9hG5mvPms0/9D2NpDZUHWXrh7ur9wzOQH0Z4f+dipLb56JkI6VJgagWyf0NqZYvF0jkYECTDvnJgWLNFMbs00WMcL8dXH1ib5IxVNagbiJh2isZ4553bN1e4IIyuNR1qUeQE7mCQ3jd+cThtEFYv+0cbgL9ZON96p/BZYMMA2Ogxv0Ew8KT13TtmVUyugsjdlkCXPjC6xPIBSbEIbI2jtCCji2+tWAJsRTiMX8FIc5SLo0G8KubamtN14ZHS4MGWcsMcZwjVgGoxNkx4frWeha2ikCCc8lhSJCxA7cewqEjG/e0tIOX8ZXLbm6SkGQFJQn9qqi9qbHYsfC/eTynJqgEr+Mltu+ZqyvnNFZZ1wW47xl85UjzCUqKKmzWSwzxkU3fDMPSSK6pddImDLBtUNuhckwbdcI1JsRTZVgtUKOYKfPkgH/gNrwwSQejkZrAKvzQFgGvMfmnzYqDAFbREKKC6AYhrnpjAOfczD/FLUfwHMvlpKcPket5PMOjnsnFDNx/I8D6k+3RIdNb5RVxDsXkTW4ovg0l5mIPyO+UCL9An8t2tBwfrJxRM1b4vNVHc39GSm/fuJclrZsa6QZPhciBN26wxPZryRrwD0mzwKPl3ZtxGwJ9qO2mt4xr+hn6yJtH5DyqnxQRT5i8XqlgF5pmsxYPKSDgD4MWrd59IZbYwuCNiKVrhk+VcaaSv431AqrEgzNg3wKPUqDO5oJNCY5bwXdHkjwGWx53r3A74DI3QkWuaXtGiGnD7Y670oLvGWwvepb/LLxCL3ZcO+gEcoMi8CL3c\",\"sig\":\"98bc9d7ce37a1c9ab3df3b375902f185950c8696dca9700f0a47a2100eef33aee994907f4923c3a1b53147ca2a9e92995d87fbd574e5028de607da291d6e209a\"}", + "raw_rumor": "{\"id\":\"18c1e8d91f002c999ef14227dc757aaf6c3fa088d7bd3d956dd15d16168d0227\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"author\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"author_previous\\\":null,\\\"author_sequence\\\":\\\"1\\\",\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"created_at\\\":\\\"101\\\",\\\"order_id\\\":\\\"7272727272727272727272727272727272727272727272727272727272727272\\\",\\\"parents\\\":[\\\"46a96db48adfd8cb0bd89b33a169fde05888c5e1dc1fd5157834f5bf6bbe452b\\\",\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\"],\\\"payload\\\":{\\\"expires_at\\\":\\\"240\\\",\\\"quote\\\":\\\"ed98c80c208cdb02bebac3091168d41fcf85b55cf2c339f19ed260d7fc86b81a\\\",\\\"terms\\\":{\\\"buyer\\\":\\\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\\\",\\\"cancellation\\\":\\\"mutual_residual_v1\\\",\\\"fulfillment\\\":[{\\\"id\\\":\\\"0404040404040404040404040404040404040404040404040404040404040404\\\",\\\"terms\\\":{\\\"address\\\":\\\"Private pickup\\\\n🥬\\\",\\\"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}\"}", + "rumor_id": "18c1e8d91f002c999ef14227dc757aaf6c3fa088d7bd3d956dd15d16168d0227", + "record_id": "93fe49c0fe9f35d3d0a343c9ca12466a0bc614a36e86b4b8677f4d933b6923e4" + }, + { + "name": "withdrawal", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"d6b6c7496171e7a19088e85ab1b7271a04ef8759120ff843d2047c327f71f900\",\"pubkey\":\"874de6497645f144d1b63414c7b4310105089b0b4c6b6fb6e7da41125e90b471\",\"created_at\":1699993995,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"5e1764097401d0477007539815099378e8238a421d925644a7b3dcf7c1eb1dc433bebe810924386290bfb53b2ccb3190868a8b0c9d441b740858be2ebba2e667\"}", + "raw_seal": "{\"id\":\"9823d6a218d08b49ace829cdf1c196575af2f47f340bc7e8f6b167b0bb2cf84b\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994996,\"kind\":13,\"tags\":[],\"content\":\"AjQ4laGnf4t0WqBgf1rStpsrP1ra0wJv6yRY/MxtMIEyBnh0LRJcfz0MTCI1267vdjmiJXvYjh06Y+xMzEIk6T8umaEzjcs9rYD1JS2FiBX3gvDbQhff+WeYUhot/ySj8IV7C2zae54dBWqUYvF0Q5YenKQWIBef21nE0fl1MB/6ojax3zuIhJzUTa0JCOsexdC2tQvkMucjgtxU3cobfuKEBlG5D9IKtFcImGJlHa6rHTcvMmRiX+vT/Twr+wLHGh/knXN2EDciY4t1bWbVCF9vrNF4X3JMMLAghV3E7Nfjzqev+tBiqiMD3XGS38aWza83kXdzM02GrBNqfyoyAggN+97WQg5klT8OFiEYu2+Wn22uEZbDzBYRmTvgCNOonzpbC2MxBP0lx9y/XGGhW44pZSpcoIONt2NJqODQ7ERS/qU3TFLhbGl4HIVja5+t5IFWYX2o/htwcEYiMzCNNHKg/6s9Ueq4mhDTDKbooHnYQmfQo4N1W1l9MVig8JnX9te5rllKCFfnnJfB4jcUqAWbjN6CQCexrepPrvyYxHI3wC8samGbUgQ2C9cPfsxjjhivoyUtWn44bgcWJTsRp9fdozOpYB80IgU0Yy2FDyNako76YGJGXYjAXA/aqlQIguGnCBTI7vKweXmeTO3xLaJ78GNRMQ7L2pdQokfiVL7WSXuz+uwgmX8EBM6p5e9lA0wnoAI+F1xD5jXuxGC4TDPXPKFDrIj2C4qddCmchJ3WxwEiFVk0b1kncSIu3EQ6rg8rGsodEw0R9v6qesVoBtqu+6TnCfAOUFEbqktA3OLq9Txm077zJczNDlaw6g4wpuhMfwzWEtIE776wSkizIK95cpq6mFFsKJqmhdfBsEA2kkpBBAK3Tc3d5znURit18RcK0gLQ5QexuzPJ0RQ/wCAqbR2DVl/pflXMsSaT+P8d3rQyyKcvyhDS/+gup3FbYDmNVvRYZNTo//dlJQqSwHVIY0Q534l9z8NGIvn+o9lSCSeSPzbT+hM/wrNGjIMCQgMnnxS7FY0Hgybj0ha4pu0+As+Wwe5LPM4VgZgVsd2EJV/Z480Exw2TgkpPQXp3SmGGZQjm72X8+Pe6m9BDvIj6FmLaAP1dK2SM4nrfK6oc9GEf5s86sDlLUXarC2eQOEa0HyRNXnhcqf3Ly5xjwvmBr7i8nFrpfRdxMwf4dENMS7OqkjiWB69LVliquLv5gI3zmUkeE3gi7TBoY80KGNA6Syd2OIc7gQPxrd1kXh4wF8rmnU+N24HLbIOyaAUVWv1MDRE1ja181b1ru1zE44F+kQEkZk4l87YnoCM68qTgo8bgu1l8H5cB4sbgDp5Jij3Cq4aI/Vs/3JnzMgVgM7eVtFtFh4gHOSnzwB2Xv+vYDhFVyvtc+2XtytItuvMLwkhXSqARjIxK14VnNhy1tuM3iQwSYhtc4uXvYKolhSI43mISqjz0tKAU1yjpa6RI/9uTByxtfR5pyFhbZ0mAbGUnxR74FO68pLj0BTUiJJHfRVDCVA6kkwv4WNIGms6hGCmkbJPNHylpPwq0DsbR5v9BAQzgS73i4LbrvuynW6wCw3frtFTOnRVzI9r5ibV+1iQ0CsN2wg+uxnP2W+miASuGeB+zzqOgf1yqo9ZVAsUdV3FW7cx7YT13q4XlCKp1pF8Qj4egWwNvjiW9q2fiO/oLCkCPcnQsleBcp4DtpQlpnA47vHToznYVdBiHmLkwPRTM/DTU7U3hslSWq/rpzm+VAXw/XBO2crtqMuMMWlST3W2i6Glq9CCkw99CySbKTDSk\",\"sig\":\"b259ff85f2008d0adb385d560909448fbf60d09a85996285b744fa40421ea4d806be33a08a7802a7cdf2b2c8e876e657c11532d0c4a2f865a99114415f3d81d1\"}", + "raw_rumor": "{\"id\":\"e759f31d4b25551b9ed40876748ee89d012c42bd47331b7dfb7f06a493e03e9e\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"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}\"}", + "rumor_id": "e759f31d4b25551b9ed40876748ee89d012c42bd47331b7dfb7f06a493e03e9e", + "record_id": "113eab1ef364f4798df9d434c9d0d45c62179121025b26810b2b3025392d9bd9" + }, + { + "name": "buyer_fork", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"402f31770bbc19133021cea30f00d8c2b5c8ac8edb8a2ae7d7e30812de7e9880\",\"pubkey\":\"2f8f2c98e69ebfc3b7277e359da1a8ef4293fc372e24386fe14cc4551ef45746\",\"created_at\":1699993994,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"550e537ed273dd6fe07c4a5b8178a06ec0600cf0a4294550c6ecbc3b8e018c8ab98975bb558cd35b6aa5fdd57870ce2a2781286ac13615e5491249901174f43d\"}", + "raw_seal": "{\"id\":\"8d06ed5dbc6532e6a8e22f7d1dbd2425d8e4ea51e4f0e338dff6e1029cb3ff4f\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994995,\"kind\":13,\"tags\":[],\"content\":\"Av5clNbUdsYGPCgKLNiAwi0hBNF8yFtiGOADAWD1VliZAsvXnWNihXBetPmPToFiXABVda6yvSqYT3criOZL1dwCZlB9YkIgGNEp9lMDHB8sxQAeuSTSViY5+GfM6N4x4iK1+Qlb//3/RHaLqLHzzMCJtG5zjwwKT4xfNb7zB9I3QwjHmMQ7z+E97J2GzeFGx09wzp6Iz2+vBy8wFeasJBtdt+wImZwjvqO7/aB/HaXB9mRi16MFajrtUM4xXzBzevXFUlYdsiXiRwS7N/J62WN/CW/9ZKFGo1mPDYWzbpHVfP5tcX0muOYXJOKvVwXBfrZKxdNB5KrRu4aljhNZ1eG10w92Bu03Y+h9QdX0Nb91sigWB/FLwYYVSFqOWAtkjnR0GD4Z/2aj900xtoKiPWv8QNv6jMMNh1XYsuh1aECf7O5s2xXgZtSNPvC6CeP2E5HA9QIcZDAvuBJTo3ZTYub1oGfYb3KbhiEqq64k4/HnyruHo1IW0V9PyecfGvV2to3s81QRkFXaZU9p3W9M2RvkDYJ3QkDVJizAqT9OTzqgYTwKFu37nXIRbkh7iEkKGDlrrNdwkm41rqlsOyvJgisWU58J3GZH0NZWkTkTgk58uKBaHahdB2e8jeVGGm+x/L9XRjL2LZTQE1WDotp7TSN6LJThlQGoIc2D709437oWhJ/nrOUhx7vZAHEed6m4aJWH1tsPlE3dCNaV65FrsLd7Xp4IhoZI+NgmHemMu64h6vB7t6+3Dehh/qBnRV17hSaLMjZFJLfkxWP2F/ZicbdPWEnLl55lktquoihZ5TVw9dXzXcw0L31c+lJLNQGYtBpibGfu3JsXvuGV/qiDgSnSAU06Xp6xqzXCudNeg1HCWVni61RoKnt60mo7jJSvtWCmQ3YrM4tx2x9SKcHfIc5PDvFzjZxlnWjZcj4iAAQCzpObqaCXiIAAFC/FB7DChF6fCgRazvv73fqPz21Sr/HM+Uf6QgpcLiW7lj/awd+EzlW/IEPGKzsJ9MvnsSqyLnRZ/8OYw6eGgyUyZdUHjI6nMXCPAeEWhr6LaWAG7MiYWnFdK0xlzJuzsmDZuZwvwMnSFK2f4PyfiVUnz5H+gUW5ZeiBB6qSn3VOrhLOgk9PDJt0d5qUJqtz7McF8pdNou12URJhuG72fr1bvQ1QXARGJpbehxDAz6CPtXT2BEU1UYoEU2/ysmZ1/tW/ACoK1F+KvMEQvXrjV+CugSQw65GGJlrV58PObzBH8qZyeCcqHSJavDw9U50qsTjdbp8mlhfgrsoAu+HDRQ3gWsYCwoJ3L0D9k/Ul+gJMAFOA+Nt1xTykF2YzvLB5cnlcxwUmXyTQWthdWWU9jVo4Aaksgi+z/AhWB8eBTJvfOvkLfITQPKp4+MZq0EDE0vnaW6aEWCmAasTO3jMMl64kEk5WCwKyyMjBlYZ4WSBiH6tbJrdDzKZ7rcndYcXwBNXOebTr9uHVy+H7RjwQuYtlqrEYuwCX63wN6u08moliBSmkhabn/EQRMu+yQbhYWUCeHH5/xTRasT6LWAlduNe+de56KIbgrBAUF0rdu1b5na4J8pcD3goD3IccX0+axAbEbazpnEoiFdxBj0hucbPJMikD7y79gIC/MqDubBHahsYeAjGf+rhWPGw3FW/6iOCfQV0hukHJwuq8L2GeUXVenVwkbnRdHIgE2SN0c3IOQVKn7AmShXsU3hWEeowe25qgiPryybKmdICPJORdRoxZQekNP3k+IJycA/AZfvKpD6+jWmSbJiePy+4Dlc/mVj6EYLUJ4/6V\",\"sig\":\"04b39738b7261ec3732fd15ee6fb463c1daac3f6106e993af2cbfa738a2ebbedf8bd92a8255bcec88213a11365e75adac95ab5c1bd250fa9dd202799d810b73a\"}", + "raw_rumor": "{\"id\":\"284a8a8a9aee741256d70ef6fe265ffc70f3d80e9e518545dfc856a386dad9b1\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"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}\"}", + "rumor_id": "284a8a8a9aee741256d70ef6fe265ffc70f3d80e9e518545dfc856a386dad9b1", + "record_id": "628f182a308bda2eb6f3875563ea56aec82dae4e491cee387f56af573b7893e2" + }, + { + "name": "decline", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"c636b278733f24edf5e330b211961750bf696339b9c8699da9f3f1af8e58c16c\",\"pubkey\":\"4081500e9b4bffa78a004cbe07221ecd43e3941e8dcfeeddb5dcd4b3c2cc4190\",\"created_at\":1699993993,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"37de0f2a1f90ada1afca2f82f6dd6d61a680548024750e7b377c3511e729b3273395e66def4c7f41c6b4c4c933d9420421d31d663f7292840e0444e9ff4e1f6e\"}", + "raw_seal": "{\"id\":\"9b86b4c62382f886581911eb5beebca362c07dc42436212e249038988e96ab5a\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":1699994994,\"kind\":13,\"tags\":[],\"content\":\"At8keFfxKQJmlQqy2pj/yIG/V15YpDt4GAzCRBGBbnV+hwMN04ccOL3TiseAzKl1PzOOdZX/g5lLLzgLjGof5LVyyTSyIOU1BzwMj1A+XlFziULh33i0Kwzw3IlyZpTUjysyVP0pXLzD4SAWbjhuNndeaaTh/7maL4+p/XnuavE5Sdp/f/wBjHQ8VvvXPC7b6Qq32Tw3tz9bYChRTIvAIiPNxgbacKjHW/j6rtfve3jhniZ3CA4iBY8nXh+/4MUhCobs2OJ5B9zJR0NnrnLwWGZKPu9W2XOPE7rExlRqEYM30K+dzmwH+10Jog5y2a2z0aLo4bmIWUZG/KXK0TpLOTmIuRrXVceKImOvVa+2Zwa0oIdYhORVCZ6Az+Z/85D6XZmJXXLQQIeZRjAd/IiLV3JBh+Dw+JqSv3X0HdtJpBZcn7mtqd5ZFbufOqaL5MFXxPJysp+JoLzVchfZs84YAXukhM559rvI8kxzk3GUl02PLYL7jsgd9nIiYtZmfKOpuqHLdvjW8IX33gW0nsBHVinjrL/0Ugw7Ohc9lNd53R+DZOMTZkUZ3Sh3QtKcD8O5sf5gIKqLqJMYzMAr4we8jDP258E2HHAuXirt8Eq9nv3Nz75BT7uxIJLbtVDIkvTKkn4Zqqp3O/OC76l08E8llyxKm3zz13nENszjr9MaJwzG3WJonZVJQTYZXhXngfwyFWNNVbf5lSa/iDimuN/nNV5esJeGCRUV20jlX890xHSpYSQcAbp8QMhOYzzy2RZ9rb4A2WSgo6kmSCbWIPhJSyjcZ4mrViQH6DbKx/0L5xcp2vpo6TbeXwSu0l8EpyUBwBhjeiI1ovgTHbggM5+dmow9kWylIeLIwbSQ9TCJDbvVrMMcNg0vrIR+voYAsvkLwJtnubc2gRWSV9Q02KrLTU3OxAp+W6sFlkSKjqqI34xImo1FjO+V23B4Jz9ldrQfW9r774c2TwZx+DvpT65/UP7V3s9BMCbsGJ4fBSJ94p44fbc960qiyUgQ9ckD/S7XKbEyV5A+5WzCnCIgkaoqCee14TEqiCPmFXL+TcetfXhUaq1Wq67RjSqkqTmR/EHmEfTF8VAMk/E3AvknKpelQSLzY4N6myemtKGCjDCXowb2J+JJQaxoLPwrGcNYWDNVDJVPpSjPle9V7IRx253OMEax6Sp92WnxXMbdLFErW+m0FKiRKCFJOoQV3WrgY+H9EBqgdBrU3aydTVtmL+5oT/nzjhm0+csbCAJMdTbC7UIFrsLBt/A8d/E2E4v8BXN5SlL57AFXq1SlPLj9PE2qk7fEQnr2ekpKwytif2UHc2COHeezZS3joGyFzO2imVj19RtzEc+IXbWz3md1iTPB/ScarSCV6mkql7cx4voDvwT/MmbRR0gIVYBoGC4CnMHo3dXil6VGKqanszkIEPBYMf2AW2fuvDRLOkJv9TBYeJVm+TkjZe17r1oRkfi8qr6htUAFu56F5v2VqHtBkqNi7IP9aOR8onETPTgvHBW3LKcEnhU48OCI1KlArf8Mq7L4Ty7MnF6aHa8lkzku1RYSSsp5kIlRaDfp7oww9Ob9wRTSR6+BTw+BDFNP/LG4uKXx0kOabAHFf7w9aujnvIe5j799jD7gKk1aZbJYQR0W+hxSHfu0t8OzpWgt9QxmSGUvzDLw0L4nd73P4blrc3r1MhqR4NXmntCO5qxzTJhWXRsQBOqKKQYa5SSAfmpTaM4jY3OAJpkFE76RRiPAgKxyM8ftgBALRdTfxDsKfy/W+1p4lfnYxEgtI4Y2fqiKTKrG2cV3\",\"sig\":\"54a191527b7001c95a4f217131177a42519d3850ab2597c0271c94e4e85ced935efc0cb22cc1dced0b3593b4d4d85a5a9e1c1497c9621dacc3383439e8e709cd\"}", + "raw_rumor": "{\"id\":\"edb9659235dc5313500648ca7907f456f95aec1de6c9d83333b3c47ae1666539\",\"pubkey\":\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"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}\"}", + "rumor_id": "edb9659235dc5313500648ca7907f456f95aec1de6c9d83333b3c47ae1666539", + "record_id": "d58afb1c571a5fba2b19caa48ded5b3f0b24b3b67464d7088baf55780522d813" + }, + { + "name": "missing_predecessor", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"7b3e6f8fde0f07ae1e995cb7a3a54df168f4943611da54ebaa29415c06ab0cb1\",\"pubkey\":\"1878acdaab8dd0e2a088495226356ce57457567864da41c061a83de96277f67f\",\"created_at\":1699993992,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"e53990352417ed9608cb63159003669b71bc7119c2f10f7c67c6fb2ebf75f62ba34ea17a473f2cba55c55f6169d2d3085b21c72e35986c1cbae830514d27254c\"}", + "raw_seal": "{\"id\":\"4e67989427edb2a978439224f8f3316638acb01bd4cf176505de81b8df378866\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994993,\"kind\":13,\"tags\":[],\"content\":\"AmaFvbbnUd++E3568WCagkr8KR32hPjc8FlBnVd4G3CbUrywgjpjBsYPAinrI3E7z+o0HQuZSwMx6UqjAdWXgfhDejZnswjJhe81DL9/MtqupsKIF4As2TtYMO6mXbLc49Q9G1rf3FoeDtpl86IKc0gSmhnN4XCfidfq3rouUgjv14giVu8BcShU61ZgQBxOBtOOYA0CsW+XNY+x1wMfQvnMk3iWkDmowvFtbV4ySrfUBUvdf/7Ee2HQxi0Hh/csTCxBwQA/InF7GD+M1VVcywVepo5HEYVtZmDEK70rpBuosEW/7YLZVMa6UH2bPu6UacqIL70sa+wBqsR6WlAzfqN29OcOUzxcKt8A7b1QKKAq0ZuMX3jWTInG9C3hAdKS8U/7R7RIwK/9h5swPnREpHV44mlHqtjrkPH6MeriUxn12b192XgE1KWRlBTnt6J0pokMgoK7SKUNgBZy1ysZSgyL2yUrz1V3hBFv64anDSajFsjXpLYsTuWgoj4FVTf1H0NuI7tybqq1q0C51m7eQSCCH0KDIMULHUrsdTFZOyNb+WmlAqPL065vwth7bZueub05JgCuQ2r+ybPOtntFoTYlP7guehHd05jq5REVxLbpvOn1wfAN6tMM5enIBxXrEsU4pxNLEcednhCKoT4YgUP1C5+JwY5IA61uvSrv5yWfQ2nD+i1745jMtDKyDG+gc0eMj9F/QhHdINtxUvrymnXcDpKWXOU0k2DCc6sYDHGlUKTXNDGs07v0ukvKisN/5DXqz8CDXfebxAuVxNTPL1D0i2kfuJAd1R727hbY1olIqLM3zjC6iIIdU6HxjqBw68agrmSk2ui+h2MhFXkoZJtKFu/iMZhonNzPtyOFlkhzfJalmMGW4SmSNYmicRgi9bYPFgpZS/JmfY7w4glFsCaFAB8r9aPS0mtv9i8s3MvV2fVNIi/bAvtHd0qQPTjzoqKEtzQpAySW1KrRfwhntyp1URx95/J+5279VeWZ6WxCStOV31iXcH8656coMfUISOO4nL1LowrfJjSq41le3KVLET3cNtXaA/FxIN9dRrM23P9qWYHWW3Ha1u9PQQxtRLxvHZgqwInYD7JqXEV9UpNfh5haCScuMxxmxzl5BBQ3/fenwI1R2Ggn1mfuY+EmhOwxK3T7/xz0dKrAWqxdeSztBHhxYlwTC8Za7k3sItbWvp9uu0kwBrXjHZIK0Miw/wzYF/IlJEKVLrJ2u/QCMkayGeOZ9J49zLRVrQKHevV/SgAwQsuFOyU6v83BaOdS21oJpDK4Q0MWAZSYG9pBRadhyjh32uHbnriwoRJA4mVJ8m55NHZbDpY99h1DE2ec3VULSENBD4jR818KXyWE9PUKi/a6UcFo/qOtSuRvXmHPNTXZoWLh0hrulwFTHrMIhPay0X8k2sejTlnTKsTwkOE/kAX+MuaoDWTj4gKC3YnKIGhdvgH9bXnJN+LgQcfnUgseXR3x8qU+v+U8HTxG08LLoewMpX2kHWa1JlcWeftDLLQC9HLM3cn+JcQGteYjvbP/MjlUSm1SrRzrp5YgSoWBMG81Fl586GX5VJRSrLjmfzz0QvPhyYnucyzueUCuZkc7NuwsJIpuNt4CaEsqFyeKSqZvPXOv1Rzj5bkJChV+IOp5rkQpJU8lD/z+vThQrLxBR/tTAgl6uxi02VN1gjWpfO7lQHfd89woTM34YTyuuS0DfPO1DJ0zp7tdnPRGAzG7R2QA48QGO2CcvPuGa2EwqNCzgGKAX+QlFyIvHF8LQYIJ/ddKoxdDrp311dWEZdzx\",\"sig\":\"78f5ed710944e7bae1bdca93905978570bbb873094987502f3bbda7384e5eb67ecbfc3c53c763ad639281644444629841b4d474630269ddb7038ba1aa61e6cc1\"}", + "raw_rumor": "{\"id\":\"2b34cae14cb06937c9404c3cd5698fe8e018531ae1a57fdcf3b64e223528ccd5\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"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}\"}", + "rumor_id": "2b34cae14cb06937c9404c3cd5698fe8e018531ae1a57fdcf3b64e223528ccd5", + "record_id": "0d017f9ab4336e81e90e054d5b4c9fd7c29b12422bae1df703cff095f8bc2770" + }, + { + "name": "wrong_predecessor", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"4b8d4e53c328be7541fa22d1ef33ca9abdd2dac1640d0a419e3922c9273f744c\",\"pubkey\":\"fb57f077f5c5fef84a8b36a1c5d8cc748c6e93d8a6943b817aef5ab3653d7343\",\"created_at\":1699993991,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"8b5a8b7335bfa2a2c324ad7637a87b84b669bf308d69ac6406b24dc89fce1d3860ce37317acd6b4b663159217c5319012d0c6cd0d0a0aa0fd578ffcdb009bf37\"}", + "raw_seal": "{\"id\":\"9a76bc4572c548f16a28778cc3a89c1087e2dc5fb53d0c6108b631a353baa989\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994992,\"kind\":13,\"tags\":[],\"content\":\"AtRZGtfu5X5IaOwN0NYVCdtr47/sKGeyyrqitGtnwR/HUGpV9MY4W3xLig/ycigvZf+e+tI7Fm+hW1LhSuFSCW2ZGlaIMlvWLR7NfIzu/n7ITbDIkQGNdgWNF23mqdgNeHQ7xqWxb8zNAoH4yVgRAJPxsAkxPXoYqqmNRbfKq+sPHYzNG5TB710K1FMpcF9ICuL6FeBmO3xuh6oPdEX7lbo2OpmfSBEpBMJ4HLa1pD2awP5cgWCts3y2z1yEeMkBOrYRJXzUN+fcaVtZUH9VO98uVg14Mj0Odkpnfg5QVpPTHAdRbVFLe1dUVTS5W0VvZXWmVesCLWxdxLelUocph4+P/2816Yir/ZkYxhPx2hmQwGu9b6+rcrweqA7CZ+Hz0SKDYZtvGIwooeMvOn3X6YwbwvR+AgqtXn9pNv6rd2EivE+/bZA7QvfLMUelZPzrB1aAa1sCyHUvKm6z7Xy0D/YbeIt1jYs6NoHAW0H8dCrB8ElohZer92JD43Cg3+W30wfllahmWPL8gCxEKKa9MEcdNUSZMdUeWR+0wSquf+yiG+uJSCwGhTTMRkf2UL6N8NHrWoIfii6J7RzEWZm+XtBwwiOzniYm6Ek1ylFV0jj+67t4EGtYhchPtQo304vCNTRha8IiWaj3D8AICVosfy67VrUHhJ8xqOi/tDtJwKOrecNkpIdsWN1Lzm12XYYZ914rmwt5SiabSxTBn6w00kBb8aGEb7atbyQUcbPWD8iO7cv3hpb42dIxg/dZjL+Fmq3DW/fi3ATU33Q8aPeG1DYcdOY0X0V1Ri9mmTwZANg7JJlFhWg6g/DBsHALopAqQIw7QTAWxdwd9Ejx7LH5s1ZMppJmkxGMH3VnnqgTNugCNEG3uyjiPS0oUcw6EoVw1XrdZE6Hy4Y4c7U7gzMdL+1r7+V8BNBc1w+va5ha4vV4dFOJvrDu7mDueO2NJb6u2GWz6l1FFW9h48BxRpDoelKR+Xc6GrYP1c8IOF9YX//C+7wDNhBXmYVgTFKtNMAq/3JDB4GlHbv+g6d0d8Qia6Ne51qPyfYstgGbEskya2OaZPWhsV096ezu++JDLkJb2tzFNzxEOfZGGvlMRSDdLq+fudg2wOGBb2MxCPK1YHesCpy+LZvHJs0OVYfh5e6RA58qfbl+wxd/18CLrv6daX+w132V31bHgBKyOcUfQ7HHegH6BEOuV9urqIEkf1zfttMwmOZB9Dj/Cz3pSTA0/QGwB7gDH7XbBzRzKoz2FQh8Kd5n2iv+IHz2lZZTC4HO8a4FVepmSbGOYZQjBnPIKOtl0GDlpLCLvd0zS51W2r0lrjpjVxD/XjKAgo9hef3zDZwf62lICUe6OhFeXuZR1AVRlo99DlYRRkppFMWJ5DhDLeNCw2bApW3A0PaWhWBkKjyFRI9mt8ZBa0OiwjdUpbqG+T1JvJybTtdMTrEp01swzVXtXZRdn1SDN0Z41xnvdkkWapq72pUkBK/isQh4MSYsoNIFtYm39hdM2Vjy9GVBALRHPIVMHQx5YtHcB/p200PqXzIwFc9D1NAbuXoryC+72DDLxYpX/wM91IcnSCsmdGug+8pTNcwWoptgk1/xst6BP3qEw/bBULDW2jCBB6Np5HYOF1jXIp9YgylmJZ56Wqx47kelWF39agouvnRLJM5WEU6UZf+HguVB5YuCAiNdlVB8ofHgyTjfAs0IxVNvRYGgYzktxb43qeTBbYJ7afjdPo1d+XVU1EIg1iNqlUKJa2Z5cac6w1rWnbc/BJoAkY+k7+udgjk/BYkjC45Kjy1b\",\"sig\":\"7dc3634ca0eb2c2426e680d587925164f0fabbc0be449d019251989b6ff186b09b8080c32d5ea5dcfe3dd30ecef55db476a4d780600eb813febf005ef3ec03f6\"}", + "raw_rumor": "{\"id\":\"e500c2482acc59e8a990daec13ab5bef85906e7929361dc0cc3746b873ff27f6\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":101,\"kind\":8890,\"tags\":[],\"content\":\"{\\\"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}\"}", + "rumor_id": "e500c2482acc59e8a990daec13ab5bef85906e7929361dc0cc3746b873ff27f6", + "record_id": "1a273f2d69cc0e5b8f449682e9b33c399f5d7d69bad21eb5a10d71686db51511" + }, + { + "name": "unrelated", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"95bc1f0d4990e6466e03c7dba5f945e5a027fc58167ce0cfd7a1e5e9f9e53fed\",\"pubkey\":\"08cf281aeac4e4e27ec4f3cdd1373f62c5a17b0f49cf69c4cad8c4bc4f5618c1\",\"created_at\":1699993990,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"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\",\"sig\":\"1eba91335f128e01793fa1561204bf32e9cd9938fff7f8285f61dd59ef8973e57a449aca2ba239dce201d3d19e7be5816bb8d2e8264651f5d4e8f65ba2e3d323\"}", + "raw_seal": "{\"id\":\"ad4c8f6c13c15be96c1a048cc67a30e80baaa9036ec0d0b82506eb9e197a2644\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994991,\"kind\":13,\"tags\":[],\"content\":\"Aj6B4vEVX2JYm8OfoLDwYGIKY4GM2+denmXMHA9MCwNCTpcfjr1IXeRdDBpIjSEeU9bVcB+qcdlt7gKWPES4OMBeA/f+S25v9/nGJT+iAGdazvuqUhisFtJdGwNwjeI34AN7dMr0pqufAS+Cd76DMc/XRhnvNbAokQY3TXlbXCXQSixa5LjHzX34EkA77o6VCrZ2/xJAzMG3yEyapFg+LnIbxKjt3Bj6w7FiKGZq72XVSFYUjBO/pzlCVrdpLdzq3WNGhw3KsRbF7h3RGAwQwIavvmM7KejkylZXikT68r+68e/de1A2miL5E0GwHxX+0eJToYe7AuDB1RlYqz4Cj/DXJA2f8pZjM5yBSl4T3aQEN2shii+Rxmw08YwLv3Fjy4sfpFowr4631C3ch3HPG5QuTR7sii58IVjzuNfHSNob5OiMKgP68GePIm9joTuOgZwq4hk/kLiRY07bqTJiUbRNL2ABvmSw7e6vwFQQMASIQtdme+1vpsb+KNCAKwhM5heTgTl0mNge2vNLtxvah5MeM7B+eyYgsO+0bS0LBaAdxuEKo0FXrPbO6hK9hSiqBPNSx4tXSMMrxbsayWrBRfQjvobdqkjiXuBILaMc3i7xhxoayHkrXGWRLvj1VYbduqK97vd9oS7FK043mhdY0it1tkCSsGVP3LYWDUr1NThnR8zgfo0scwRZpQp4XVgdm5INrE0E///w2t0BAeLdQc+BPtg0IrWup8Eo8NkIPRcRMkWXhQfJhP85vJvlR+Woehoj36S68NwjlkvqQIR8s34OzG9gE9c80nWSoNdJwmG0/C7My8tNoRPa/NJpp9ESAlCeo/dPtE44eu/fApC2sg6IRIaFaRZDvKQYDeM8KQuJ3ld2kIbPu8/+oqJozBEgZoRJDMnBrTEZgILX2t4pvhz1w8vPTFo5ESE996bgWhKiqFZSny5c3vbRE3x0dpZ3U6Wyrvn4cG3aC0TtLlrIDqBqnweoCTCNVcF2qckxorS0EHLtf78hDW2iVPBBwAeKpkWCcuaYXto0KL86pi4CuJ/n5x7OFCG0y1ew/+aWkdDCBGl3XeR5MK7LXVg7L7dcyckCfCCCzD6Ass63GeBQKe2BFv2QmPwiAHmbLmfvNWTNODdv1uNliDYd8ibT5C+WKuWOGVGDoaXdGrbNkdSYBY9QF2btyKCMjrOcQQ7o/L/QVrtFRWY+i8zPI+JzggS0NRcC+vGMZcUkZJwVeBXgQTZv4RlYy8CzyXvKxQjRzJKfdE+SmHraS+CPlxPnPhd9YQNtJNNoeVlJ0fSLSFPkO8RY9hy/RVlmpntZYpXfkfncHQdqT0hyFq1TXN913CJGwYP+7dC/mjLNM5Gx0STN1uataYEgh+za7mrdBEqfAEiuI7zj99b1G8oHJeac+IkHisBVr5ZLyTgjD27yfP5Flzr3HzSkrGPPMH6yh1JhT4g+Ioc=\",\"sig\":\"9bc2b599fe815cbb0cfec9396366c2f91b736cf3a852ce382f3d011c23d2878fb2a4d6b9b31fb65b7d62b851749aa0e02a4d8795826153f16eb1a05eada845bc\"}", + "raw_rumor": "{\"id\":\"aca5277b29b5b31c0ed3aabfe0d800bc2e41237e6e89b92c91494bbc7dcb11df\",\"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\\\":[],\\\"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}\"}", + "rumor_id": "aca5277b29b5b31c0ed3aabfe0d800bc2e41237e6e89b92c91494bbc7dcb11df", + "record_id": "44b6ff2b1040a1bec19144ffea987f74922fdf72647e8c2b9910cbb59fc30829" + }, + { + "name": "future_commerce", + "recipient_scalar": 3, + "raw_wrap": "{\"id\":\"01739b8340b9f6830d164c42b659987ddb55e9056e844c7d71ce3f28572bed30\",\"pubkey\":\"f403ff699c5d4e7a53742af8b64e00f2abbbb4c37f45803d4a25637fb0ed1d9b\",\"created_at\":1699993989,\"kind\":1059,\"tags\":[[\"p\",\"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9\"]],\"content\":\"ArqKFpoiDfx6EL5xCD/v2EVt9MmnlgeIYyUab1HrTNqoIL2beaRmGoJRE01XvUxGeRSpMMvtRETj7ljg0HMIaqVqqSx2vnb4rZFmTUH21IXPOduMsGSQyPOakEU88t3wRLaP87/Dj8qFa+vt68fCK342djebNXvlJB2MC4WLSC13ZV7eMMZBsKKcxiqvNOuEcXjcRQQy9knX37rKmAWrF+QvJTQKCAb6D6O+q06+efgXsB1z1U8Ln6nnP7JqCWGud/3TRdHu2HxJgVWBxbYLg2PHkqgm3GEfPSzxroEEsz180hT/pK0NYu8MU6aQWEW2n2jt0dSc1t3JIFKfAVel22SnAPTkK/VqRoLdN5PMI+D3yIR8UxdVoT/mnLjK352ncnKOzEy/gWtkx0Wi9b9EGzrf9Q7j4ZbaUPR+eu1PsFQ4ot2N0C4u1+KzPV9rR3OSIGVO6rnXALcxXGE5AaoYSZnjL8vNvmT6yeicspHS6hh+7pUtvXf43ryoblRQahLl/hXvjWzvd9xrUyCklRKgPFwignR/8ecIs31zo2ofSdMV50TS69e3uWbLaA8etlOem2+nel6sGxK+4OTWavBYkp4p5RRx8hQu7aYsfSwZwXhfQ5+zyUcp0cj+RC1nO3ayZusaZ7R6kzis+VLmiRo8XP2AkAxnvN0qb0gEF78TaUikM7RtsSP7kGMYHBT2LKWldEtA+7KBA+vWrqWgFBWjo8bOnvmx71aqzx6kN2E1gA/Lz0va4ZUULKXADpar81dwQGFcxqjE5SHdigKm6FtkRJB+y/AYpFNQnxlM9xG5OmQwEc7yTXBKZJo1Eo30UpgbAp5qgrFOhDhmC6ZCcF8xeTCLIU2jN7j0CfwadqTKI0UuU9K/o9aRk+zlHYfFC3rGAA0hIeOKnoQw9yNFMLZIjlX9emGgXncqtkIHXUJ9nNK+E0+Sbqh4nRhkA1cU8w0iS/DzjFL4af6j94zEzGQmqKBrjF84n2jCvIXp/cDZnUVAInw3PjDHuOjXEcedoDWA7jZSxcwQn9SdTtjlEcI3SPW2Rp/aPV1Mpc9f3M42VYrd6vqnvrktvEr0F7g3kn7RYO+Fl2txrAkOQzXP0x8DkU7/GoV+noTKWzXFfyd6/JOUAXSWV9LXBr5G9OtoYXd47P24RSn64ei2whurSqIS2/KWx6Vv7wIJp4Af+fHdBDzHaUNFBUAl8eqpgtwc/qpD5nTJT3UceyLkUzic88Wa5/ZMO1vqnlO/qZVqGj4j2QS2JPYoe1Yrba882MNKZxIUkB4i8xHEO+womS1QsUCY3oOI+eSTQI4WN3Vkm/tSG1K3yzW6D7f6D9kO64ARZ1jf0rU38ioS0vnq+qf1L4d3WTNmA85KdlmVD89UgxJJVGSae1aL5u5cFTxO34Kn9hxRwPaJAnSI65QoVtEgSxoMQwV1dFRBfB6yUX2UTVaLQ7kpo3s=\",\"sig\":\"5d3a5e476ba5464157c0bdd24b642a3e2660bd9976c141d3a977c39ded4b2e2cd459b1b561d8de5961a99ee15058c4d19ea29ae18cae66759b916e5198de0ef5\"}", + "raw_seal": "{\"id\":\"08e5bdc1326eb410e626f6626e134240f5cc4f6b5c98cd58ceb7ab747d7976f7\",\"pubkey\":\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\",\"created_at\":1699994990,\"kind\":13,\"tags\":[],\"content\":\"AnrjFyhIBlUudv4+Jx/m5puMFGOi7QkhQwrUoZERZ7HsfPeyVsgWO58UnxiRpyiulxERbw5dMyVGP09vJMG00s0kjPWktW8L2dL/ryVeWpuzhSJugxjR8BcyS4ApthgXIx6xDVOOJEr/mjXDaKWRewPXyND3nUQdhEaugVaS5r8lsQtQyrg01faIGAie2pjvQoZgKlz9rMqWd/69qfqF/53JQGVsB4oe9Cuw3473qbKxIFxmVfOkUOTHQA51hFxY/ypuvVLQMr/DqHAo10PXXCJA1wxPsTDw4LjQ3aqNyDVogrr+UxUE6HcyiAnbDaDqB/daIYk3TW5ordR3kxFH5NerAabpGRuPmVeAIPuT9O8MgjNYnf39t1nQbXDNPSkHiAAZUwmJAIARa9WsZuxNUEPUa5AHrBj28MnIghft5qXtbxu2/ImzCvGokIGyYMKjzr8qbHTQum/NBl4suYZn3BuLdXsaZeBddJBuB8VD5piZcJF/U+cogvm6Aou/yM/7beJ625mlN7g1Uqml/MwiGVz5T83DMVy39fXGjK+S//kqa3Ihnrze7C4YhfpcdU7u2XwksJUQm9rgnHAvAL4/w6li3A==\",\"sig\":\"3db31a0faf70ef2b2d5806274b3851cbeb033a02a6998eceb4ef319ec347a2c840f274f05769c8fb9eb4155ef4dd269f4e2c0b1d4a61a8fe267d52e321a6f0f4\"}", + "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 + } + ] +} diff --git a/tools/protocol_oracle/stock_history.mjs b/tools/protocol_oracle/stock_history.mjs @@ -0,0 +1,74 @@ +// Independent synthetic causal-store fixtures. Fixed public test scalars, +// nonces and auxiliary bytes provide no production custody or entropy claim. +import {createHash} from 'node:crypto'; +import {readFileSync,writeFileSync} from 'node:fs'; +import assert from 'node:assert/strict'; +import {getEventHash,getPublicKey,verifyEvent} from 'nostr-tools/pure'; +import {v2} from 'nostr-tools/nip44'; +import {schnorr} from '@noble/curves/secp256k1.js'; +const root=new URL('../../',import.meta.url); +const read=path=>readFileSync(new URL(path,root),'utf8'); +const sha=value=>createHash('sha256').update(value).digest('hex'); +const secret=n=>Buffer.from(BigInt(n).toString(16).padStart(64,'0'),'hex'); +const publicKey=n=>getPublicKey(secret(n)); +const seller=publicKey(3),buyer=publicKey(2),oldSeller=publicKey(1); +assert.equal(Buffer.from(schnorr.sign(new Uint8Array(32),secret(3),new Uint8Array(32))).toString('hex').toUpperCase(),'E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0'); +const canonical=value=>value===null||typeof value!=='object'?JSON.stringify(value):Array.isArray(value)?'['+value.map(canonical).join(',')+']':'{'+Object.keys(value).sort().map(key=>JSON.stringify(key)+':'+canonical(value[key])).join(',')+'}'; +const publicPath='crates/nostr/tests/fixtures/public_heads.v1.json'; +const recordPath='crates/protocol/tests/fixtures/commerce_wire.v1.json'; +const publicFixture=JSON.parse(read(publicPath));assert.equal(publicFixture.author,seller); +const listingRaw=publicFixture.vectors.find(row=>row.name==='listing_fixed').raw; +const listing=JSON.parse(listingRaw);assert(verifyEvent(JSON.parse(listingRaw))); +const profile=JSON.parse(listing.tags.find(tag=>tag[0]==='radroots:listing')[1]); +const templates=JSON.parse(read(recordPath)).vectors; +const template=name=>JSON.parse(templates.find(row=>row.name===name).wire); +const thread='71'.repeat(32),order='72'.repeat(32); +function sign(fields,scalar) { + const event={pubkey:publicKey(scalar),...fields};const id=getEventHash(event); + const signed={id,...event,sig:Buffer.from(schnorr.sign(Buffer.from(id,'hex'),secret(scalar),new Uint8Array(32))).toString('hex')}; + assert(verifyEvent(JSON.parse(JSON.stringify(signed))));return signed; +} +function encrypt(raw,from,to,label) { + const nonce=Buffer.from(sha('radroots causal fixture/'+label),'hex'); + const encrypted=v2.encrypt(raw,v2.utils.getConversationKey(secret(from),publicKey(to)),nonce); + assert.equal(v2.decrypt(encrypted,v2.utils.getConversationKey(secret(to),publicKey(from))),raw);return encrypted; +} +let sequence=4000; +function enclose(name,content,author,kind=8890,tags=[]) { + const unsigned={pubkey:publicKey(author),created_at:typeof content==='string'?102:Number(content.created_at),kind,tags,content:typeof content==='string'?content:canonical(content)}; + const rumor={id:getEventHash(unsigned),...unsigned};const rawRumor=JSON.stringify(rumor); + const seal=sign({created_at:1699999000-sequence,kind:13,tags:[],content:encrypt(rawRumor,author,3,name+'/rumor')},author); + const ephemeral=sequence++;const rawSeal=JSON.stringify(seal); + const wrap=sign({created_at:1699998000-sequence,kind:1059,tags:[['p',seller]],content:encrypt(rawSeal,ephemeral,3,name+'/seal')},ephemeral); + const rawWrap=JSON.stringify(wrap); + assert(Buffer.byteLength(unsigned.content)<=16384&&Buffer.byteLength(rawRumor)<=24576&&Buffer.byteLength(rawWrap)<=65536); + return {name,recipient_scalar:3,raw_wrap:rawWrap,raw_seal:rawSeal,raw_rumor:rawRumor,rumor_id:rumor.id,record_id:typeof content==='string'?null:content.record_id??null}; +} +function record(type,payload,author,sequence,previous,parents,orderId=order,time=101) { + const content={profile:'radroots.commerce',version:1,type,thread_id:thread,order_id:orderId,author:publicKey(author),buyer,seller,created_at:String(time),author_sequence:String(sequence),author_previous:previous,parents:[...new Set(parents)].sort(),payload}; + assert(content.parents.length<=8); + return {...content,record_id:sha(Buffer.concat([Buffer.from('radroots.record.v1\0'),Buffer.from(canonical(content))]))}; +} +const chat=enclose('chat','Independent private question',2,14,[['p',seller]]); +const complete=JSON.parse(JSON.stringify(template('quote').payload.terms).replaceAll(oldSeller,seller)); +for(const line of complete.lines) { + line.source={coordinate:{kind:30402,author:seller,d:publicFixture.d},event_id:listing.id}; + line.product=structuredClone(profile.product);line.option=structuredClone(profile.options[0]);line.option_id=profile.options[0].id; +} +const quoted=record('quote',{terms:complete,expires_at:'250',in_reply_to:chat.rumor_id},3,1,null,[listing.id,chat.rumor_id],null,100); +const requested=record('request',{terms:complete,expires_at:'240',quote:quoted.record_id},2,1,null,[listing.id,quoted.record_id]); +const withdrawn=record('withdrawal_requested',{authorization:requested.record_id,reason:'Withdraw exact request'},2,2,requested.record_id,[requested.record_id]); +const fork=record('withdrawal_requested',{authorization:requested.record_id,reason:'Conflicting same-sequence statement'},2,2,requested.record_id,[requested.record_id]); +const declined=record('decline',{request:requested.record_id,reason:'Seller decline'},3,1,null,[requested.record_id]); +const missing='ab'.repeat(32); +const gap=record('withdrawal_requested',{authorization:requested.record_id,reason:'Missing predecessor'},2,3,missing,[missing,requested.record_id]); +const wrongPrevious=record('withdrawal_requested',{authorization:requested.record_id,reason:'Wrong predecessor author/scope'},2,2,quoted.record_id,[quoted.record_id,requested.record_id]); +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 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); +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({sources:rows.length,sha256:sha(bytes),bytes:Buffer.byteLength(bytes),check:args[0]==='--check'})); diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -109,6 +109,11 @@ struct NativeSellerStockAuthority { inventory_scope_grants_source_access: bool, source_checkpoint_independent: bool, source_profile_implies_actionability: bool, + causal_history_current_administrator_required: bool, + causal_history_complete_local_scope_required: bool, + causal_history_uninterpreted_policy: String, + causal_history_transaction_witnesses_required: bool, + causal_history_implies_business_permission: bool, source_carrier_max_bytes: u32, source_chunk_max_bytes: u32, mapping_payload_schema: String, @@ -403,6 +408,12 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && !stock.inventory_scope_grants_source_access && stock.source_checkpoint_independent && !stock.source_profile_implies_actionability + && stock.causal_history_current_administrator_required + && stock.causal_history_complete_local_scope_required + && stock.causal_history_uninterpreted_policy + == "conservative_authenticated_participant_pair_barrier" + && stock.causal_history_transaction_witnesses_required + && !stock.causal_history_implies_business_permission && stock.source_carrier_max_bytes == 65536 && stock.source_chunk_max_bytes == 16384 && stock.mapping_owner_administration_required @@ -725,6 +736,8 @@ fn validate_values(v: &Values, limits: &BTreeMap<String, u64>) -> Result<(), Str ("order_lines", 32), ("listing_options", 16), ("parent_records", 8), + ("causal_records_per_scope", 1_000), + ("causal_source_identities_per_collection", 8_000), ("read_page_events", 1_000), ("unknown_quarantine_events_per_scope", 1_024), ("live_queue_events", 256), @@ -1057,6 +1070,35 @@ mod tests { } #[test] + fn causal_history_contract_requires_current_access_full_scope_and_non_actionability() { + for (field, bad) in [ + ( + "causal_history_current_administrator_required", + json!(false), + ), + ("causal_history_complete_local_scope_required", json!(false)), + ( + "causal_history_uninterpreted_policy", + json!("ignore_unknown_scope"), + ), + ( + "causal_history_transaction_witnesses_required", + json!(false), + ), + ("causal_history_implies_business_permission", json!(true)), + ] { + assert!( + validate_bytes(&changed( + &format!("/native_seller_stock_authority/{field}"), + bad + )) + .is_err(), + "{field}" + ); + } + } + + #[test] fn source_retention_contract_requires_provenance_bounds_and_separate_authority() { for (field, bad) in [ ("schema_version", json!(5)), @@ -1152,6 +1194,8 @@ mod tests { ("/limits/public_event_bytes", json!(65537)), ("/limits/live_queue_bytes", json!(0)), ("/limits/order_lines", json!(33)), + ("/limits/causal_records_per_scope", json!(1001)), + ("/limits/causal_source_identities_per_collection", json!(0)), ("/values/count_quantities_integral", json!(false)), ("/values/currency_exponent_max", json!(5)), ("/values/rounding", json!("away_from_zero")),