lib

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

native_commerce_tests.rs (52832B)


      1 //! Real facade, SQLx and local crypto with explicitly controlled command IO.
      2 //! Delivery cases additionally exercise explicit loopback Nostr transport.
      3 //! Host custody and live route discovery remain outside these fixtures.
      4 use super::{Client, NativeConfig, StartMode};
      5 use radroots_domain::{CommandContextData, OperationId, PoolId, PublicKey, UnixSeconds};
      6 use radroots_execution::{
      7     session::{
      8         HostFuture,
      9         command::{CommandIo, CommandRuntime, capture_dm_route, selected_dm_targets},
     10     },
     11     workspace::CommandContext,
     12 };
     13 use radroots_nostr::{key::SecretKey, public_ingress::ObservedHead, signing::LocalSigner};
     14 use radroots_protocol::{
     15     command::{AcceptOrderInput, AllocationSelection, CapturedOrderAcceptance},
     16     nip59::CapturedDmRoute,
     17 };
     18 use radroots_secrets::{
     19     SecretId, SecretRef,
     20     envelope::Nonce,
     21     file::{FileOpenMode, FileProvider},
     22     id::{BackendKind, KeyVersion},
     23     provider::AccessPolicy,
     24     wrapping::SecretMaterial,
     25 };
     26 use radroots_signing::{
     27     SignReceipt, SignRequest, Signer, SignerStatus,
     28     issuance::{
     29         ExactRecoveryCapability, ExactRecoveryOutcome, ExactRecoveryRequest, SigningIntent,
     30         SigningOutcome,
     31     },
     32     provider::{
     33         ParticipantProvider, PrivateCiphertext, PrivateText, ProviderCall, ProviderError,
     34         ProviderState, SignerCallbacks, SignerHandle,
     35     },
     36     signer::BoxFuture,
     37 };
     38 use radroots_storage::{
     39     command::{OperationError, PrivateEnvelopeCandidate},
     40     event::SourceGeneration,
     41     inventory::{InventoryCheckpointRef, InventoryOutcome, InventoryRequest, InventoryStore},
     42     workspace::{
     43         AttachmentProof, WorkspaceClock, WorkspaceError,
     44         seller_stock::{
     45             SellerAuthoritySelection, StockGrantScope, StockListingCheckpointRef, StockResources,
     46             StockSourceCheckpointRef,
     47         },
     48     },
     49 };
     50 use radroots_storage_sqlite::{
     51     OpenMode, OpenOptions, Paths,
     52     workspace::{
     53         NativeWorkspace, SellerStockConfig, StockConsentCapture, StockConsentMode, StockEnrollment,
     54         StockGrantEnrollment, StockListingCapture, StockRequestSnapshot, StockSnapshotRequest,
     55         StockSourceCapture, WorkspaceCrypto,
     56     },
     57 };
     58 use radroots_transport::{Target, TargetSet};
     59 use std::{
     60     num::NonZeroU64,
     61     sync::{
     62         Arc, Weak,
     63         atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
     64     },
     65 };
     66 
     67 fn data() -> serde_json::Value {
     68     serde_json::from_str(include_str!(
     69         "../tests/fixtures/ordinary_acceptance/inputs.v1.json"
     70     ))
     71     .unwrap()
     72 }
     73 fn proof(value: &AttachmentProof) -> AttachmentProof {
     74     value
     75         .with_secret(|b| AttachmentProof::from_protected_input(b))
     76         .unwrap()
     77 }
     78 struct Clock(AtomicU64, AtomicBool);
     79 impl Clock {
     80     fn enable_realtime(&self) {
     81         self.1.store(true, Ordering::SeqCst);
     82     }
     83 }
     84 impl WorkspaceClock for Clock {
     85     fn now(&self) -> Result<UnixSeconds, WorkspaceError> {
     86         let seconds = if self.1.load(Ordering::SeqCst) {
     87             std::time::SystemTime::now()
     88                 .duration_since(std::time::UNIX_EPOCH)
     89                 .map_err(|_| WorkspaceError::Unavailable)?
     90                 .as_secs()
     91         } else {
     92             self.0.load(Ordering::SeqCst)
     93         };
     94         UnixSeconds::new(seconds).map_err(|_| WorkspaceError::Unavailable)
     95     }
     96 }
     97 struct Control {
     98     pause_refused: AtomicBool,
     99     pause_rejected: AtomicBool,
    100     tamper_recovery: AtomicBool,
    101     tamper_self: AtomicBool,
    102     rejected: std::sync::Mutex<Option<radroots_signing::issuance::RejectedArtifact>>,
    103     recovery_supported: AtomicBool,
    104     signs: AtomicUsize,
    105     recoveries: AtomicUsize,
    106     fail_self: AtomicBool,
    107     fail_peer: AtomicBool,
    108     pause_peer: AtomicBool,
    109     entered: tokio::sync::Notify,
    110     release: tokio::sync::Notify,
    111 }
    112 impl Control {
    113     fn new() -> Self {
    114         Self {
    115             pause_refused: AtomicBool::new(false),
    116             pause_rejected: AtomicBool::new(false),
    117             tamper_recovery: AtomicBool::new(false),
    118             tamper_self: AtomicBool::new(false),
    119             rejected: std::sync::Mutex::new(None),
    120             recovery_supported: AtomicBool::new(true),
    121             signs: AtomicUsize::new(0),
    122             recoveries: AtomicUsize::new(0),
    123             fail_self: AtomicBool::new(false),
    124             fail_peer: AtomicBool::new(false),
    125             pause_peer: AtomicBool::new(false),
    126             entered: tokio::sync::Notify::new(),
    127             release: tokio::sync::Notify::new(),
    128         }
    129     }
    130 }
    131 struct Provider {
    132     inner: LocalSigner,
    133     control: Arc<Control>,
    134 }
    135 impl Signer for Provider {
    136     fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> {
    137         self.inner.status()
    138     }
    139     fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> {
    140         panic!("acceptance must never invoke legacy signing")
    141     }
    142 }
    143 impl ParticipantProvider for Provider {
    144     fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> {
    145         Box::pin(async move {
    146             let state = self.inner.provider_state().await?;
    147             Ok(if self.control.recovery_supported.load(Ordering::SeqCst) {
    148                 state
    149             } else {
    150                 state.with_exact_recovery(ExactRecoveryCapability::Unavailable)
    151             })
    152         })
    153     }
    154     fn encrypt_private(
    155         &self,
    156         c: ProviderCall,
    157         p: PublicKey,
    158         t: PrivateText,
    159     ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> {
    160         self.inner.encrypt_private(c, p, t)
    161     }
    162     fn decrypt_private(
    163         &self,
    164         c: ProviderCall,
    165         p: PublicKey,
    166         t: PrivateCiphertext,
    167     ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> {
    168         self.inner.decrypt_private(c, p, t)
    169     }
    170     fn sign_exact(&self, intent: SigningIntent) -> BoxFuture<'_, SigningOutcome> {
    171         Box::pin(async move {
    172             self.control.signs.fetch_add(1, Ordering::SeqCst);
    173             let is_self = intent.recipient() == Some(self.inner.public_key());
    174             if (is_self && self.control.fail_self.load(Ordering::SeqCst))
    175                 || (!is_self && self.control.fail_peer.load(Ordering::SeqCst))
    176             {
    177                 if self.control.pause_refused.swap(false, Ordering::SeqCst) {
    178                     self.control.entered.notify_one();
    179                     self.control.release.notified().await;
    180                 }
    181                 return SigningOutcome::not_dispatched(intent.binding(), ProviderError::Cancelled);
    182             }
    183             let result = self.inner.sign_exact(intent).await;
    184             if is_self && self.control.tamper_self.load(Ordering::SeqCst) {
    185                 let foreign = radroots_signing::issuance::IntentBinding::from_components(
    186                     OperationId::from_bytes([0xa1; 32]),
    187                     [0xa2; 32],
    188                     [0xa3; 32],
    189                     radroots_signing::issuance::ArtifactRole::BusinessSeal,
    190                     Some(self.inner.public_key()),
    191                     NonZeroU64::new(230000).unwrap(),
    192                 )
    193                 .unwrap();
    194                 let rejected = result.enforce_binding(foreign);
    195                 let radroots_signing::issuance::OutcomeKind::Rejected(metadata) = rejected.kind()
    196                 else {
    197                     panic!("actual artifact must retain bounded mismatch metadata")
    198                 };
    199                 *self.control.rejected.lock().unwrap() = Some(*metadata);
    200                 if self.control.pause_rejected.swap(false, Ordering::SeqCst) {
    201                     self.control.entered.notify_one();
    202                     self.control.release.notified().await;
    203                 }
    204                 return rejected;
    205             }
    206             if !is_self && self.control.pause_peer.swap(false, Ordering::SeqCst) {
    207                 self.control.entered.notify_one();
    208                 self.control.release.notified().await;
    209             }
    210             result
    211         })
    212     }
    213     fn recover_exact(&self, request: ExactRecoveryRequest) -> BoxFuture<'_, ExactRecoveryOutcome> {
    214         Box::pin(async move {
    215             self.control.recoveries.fetch_add(1, Ordering::SeqCst);
    216             let result = self.inner.recover_exact(request).await;
    217             if self.control.tamper_recovery.load(Ordering::SeqCst) {
    218                 let foreign = radroots_signing::issuance::IntentBinding::from_components(
    219                     OperationId::from_bytes([0xa1; 32]),
    220                     [0xa2; 32],
    221                     [0xa3; 32],
    222                     radroots_signing::issuance::ArtifactRole::BusinessSeal,
    223                     Some(self.inner.public_key()),
    224                     NonZeroU64::new(230000).unwrap(),
    225                 )
    226                 .unwrap();
    227                 let rejected = result.enforce_binding(foreign);
    228                 let radroots_signing::issuance::ExactRecoveryKind::Rejected(metadata) =
    229                     rejected.kind()
    230                 else {
    231                     panic!("actual recovered artifact must retain bounded mismatch metadata")
    232                 };
    233                 *self.control.rejected.lock().unwrap() = Some(*metadata);
    234                 return rejected;
    235             }
    236             result
    237         })
    238     }
    239 }
    240 struct Callbacks;
    241 impl SignerCallbacks for Callbacks {
    242     fn quiesce(&self) -> BoxFuture<'_, Result<(), ProviderError>> {
    243         Box::pin(async { Ok(()) })
    244     }
    245     fn close(&self) -> BoxFuture<'_, Result<(), ProviderError>> {
    246         Box::pin(async { Ok(()) })
    247     }
    248 }
    249 struct Io {
    250     clock: Arc<Clock>,
    251     next: AtomicUsize,
    252     wraps: AtomicUsize,
    253     sent: std::sync::Mutex<Vec<String>>,
    254     missing_ack: AtomicBool,
    255     pause_delivery: AtomicBool,
    256     entered: tokio::sync::Notify,
    257     release: tokio::sync::Notify,
    258     route_override: Option<Vec<String>>,
    259     transport: std::sync::Mutex<Option<Arc<radroots_transport_nostr::NostrTransport>>>,
    260 }
    261 impl Io {
    262     fn new(clock: Arc<Clock>) -> Self {
    263         Self {
    264             clock,
    265             next: AtomicUsize::new(1),
    266             wraps: AtomicUsize::new(0),
    267             sent: std::sync::Mutex::new(Vec::new()),
    268             missing_ack: AtomicBool::new(false),
    269             pause_delivery: AtomicBool::new(false),
    270             entered: tokio::sync::Notify::new(),
    271             release: tokio::sync::Notify::new(),
    272             route_override: None,
    273             transport: std::sync::Mutex::new(None),
    274         }
    275     }
    276     fn selected(&self) -> TargetSet {
    277         self.route_override.as_ref().map_or_else(targets, |uris| {
    278             TargetSet::new(
    279                 uris.iter()
    280                     .map(|uri| Target::nostr_relay(uri).unwrap())
    281                     .collect(),
    282             )
    283             .unwrap()
    284         })
    285     }
    286 }
    287 fn targets() -> TargetSet {
    288     TargetSet::new(vec![Target::nostr_relay("wss://relay.example").unwrap()]).unwrap()
    289 }
    290 impl CommandIo for Io {
    291     fn enabled(&self) -> bool {
    292         true
    293     }
    294     fn now(&self) -> Result<UnixSeconds, OperationError> {
    295         self.clock.now().map_err(Into::into)
    296     }
    297     fn seal_time(&self, now: UnixSeconds) -> Result<UnixSeconds, OperationError> {
    298         Ok(now)
    299     }
    300     fn route(
    301         &self,
    302         recipient: PublicKey,
    303         _: NonZeroU64,
    304     ) -> HostFuture<'_, Result<CapturedDmRoute, OperationError>> {
    305         Box::pin(async move {
    306             if let Some(uris) = &self.route_override {
    307                 use nostr::JsonUtil;
    308                 let keys = [2, 3]
    309                     .into_iter()
    310                     .map(|scalar| {
    311                         nostr::Keys::new(
    312                             nostr::SecretKey::from_hex(&format!("{scalar:064x}")).unwrap(),
    313                         )
    314                     })
    315                     .find(|key| key.public_key().to_hex() == recipient.to_hex())
    316                     .unwrap();
    317                 let raw = nostr::EventBuilder::new(nostr::Kind::Custom(10050), "")
    318                     .tags(
    319                         uris.iter()
    320                             .map(|uri| nostr::Tag::parse(["relay", uri.as_str()]).unwrap()),
    321                     )
    322                     .custom_created_at(nostr::Timestamp::from_secs(100))
    323                     .sign_with_keys(&keys)
    324                     .unwrap()
    325                     .as_json();
    326                 return capture_dm_route(recipient, [raw.as_str()], &self.selected());
    327             }
    328             let value = data();
    329             let row = value["stock_routes"]
    330                 .as_array()
    331                 .unwrap()
    332                 .iter()
    333                 .find(|v| v["recipient"].as_str().unwrap() == recipient.to_hex())
    334                 .unwrap();
    335             capture_dm_route(recipient, [row["raw"].as_str().unwrap()], &targets())
    336         })
    337     }
    338     fn targets(&self, route: &CapturedDmRoute) -> Result<TargetSet, OperationError> {
    339         selected_dm_targets(route, &self.selected())
    340     }
    341     fn publication_policy(&self) -> radroots_transport::policy::SatisfactionPolicy {
    342         use radroots_transport::policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy};
    343         SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all())
    344     }
    345     fn private_envelope(
    346         &self,
    347         recipient: PublicKey,
    348         raw: &str,
    349     ) -> Result<PrivateEnvelopeCandidate, OperationError> {
    350         self.wraps.fetch_add(1, Ordering::SeqCst);
    351         let wrapped = radroots_nostr::signing::gift_wrap::wrap_retained_seal(
    352             raw,
    353             recipient,
    354             NonZeroU64::new(self.now()?.get()).unwrap(),
    355             &radroots_nostr::signing::OsNonceSource,
    356         )
    357         .map_err(|_| OperationError::InvalidEvidence)?;
    358         wrapped.with_wrapping_key(|key| {
    359             PrivateEnvelopeCandidate::from_obtained(recipient, wrapped.signed_json(), key)
    360         })
    361     }
    362     fn delivery_id(&self) -> Result<String, OperationError> {
    363         Ok(format!("{:064x}", self.next.fetch_add(1, Ordering::SeqCst)))
    364     }
    365     fn publish(
    366         &self,
    367         request: radroots_transport::sink::DeliveryRequest,
    368         selected: TargetSet,
    369     ) -> HostFuture<'_, Result<radroots_transport::DeliveryReceipt, radroots_transport::SinkFailure>>
    370     {
    371         Box::pin(async move {
    372             self.sent
    373                 .lock()
    374                 .unwrap()
    375                 .push(request.payload().event().raw_json().to_owned());
    376             if self.pause_delivery.swap(false, Ordering::SeqCst) {
    377                 self.entered.notify_one();
    378                 self.release.notified().await;
    379             }
    380             let transport = self.transport.lock().unwrap().clone();
    381             if let Some(transport) = transport {
    382                 use radroots_transport::EventSink;
    383                 return transport.deliver_selected(request, selected).await;
    384             }
    385             use radroots_transport::{
    386                 DeliveryReceipt, outcome::DeliveryOutcome, sink::DeliveryTargetReceipt,
    387             };
    388             let outcome = if self.missing_ack.load(Ordering::SeqCst) {
    389                 DeliveryOutcome::unavailable()
    390             } else {
    391                 DeliveryOutcome::accepted()
    392             };
    393             Ok(DeliveryReceipt::for_request(
    394                 &request,
    395                 selected
    396                     .targets()
    397                     .iter()
    398                     .map(|target| DeliveryTargetReceipt::attempted(target.clone(), outcome.clone()))
    399                     .collect(),
    400             )
    401             .unwrap())
    402         })
    403     }
    404 }
    405 struct Rig {
    406     vault: Arc<FileProvider>,
    407     _temp: tempfile::TempDir,
    408     client: Client,
    409     native: NativeWorkspace,
    410     enrollment: StockEnrollment,
    411     scope: radroots_execution::workspace::WorkspaceSession,
    412     clock: Arc<Clock>,
    413     control: Arc<Control>,
    414     provider: Weak<Provider>,
    415     io: Arc<Io>,
    416 }
    417 impl Rig {
    418     async fn new() -> Self {
    419         Self::configured(None, 300).await
    420     }
    421     async fn configured(route: Option<Vec<String>>, expiry: u64) -> Self {
    422         let temp = tempfile::tempdir().unwrap();
    423         let root = temp.path().canonicalize().unwrap();
    424         let vault = Arc::new(
    425             FileProvider::open(
    426                 root.join("vault"),
    427                 FileOpenMode::CreateNew,
    428                 SecretMaterial::from_slice(&[0xa5; 32]).unwrap(),
    429             )
    430             .unwrap(),
    431         );
    432         let reference = SecretRef::new(
    433             SecretId::parse("workspace-key").unwrap(),
    434             BackendKind::File,
    435             KeyVersion::new(1).unwrap(),
    436         );
    437         vault
    438             .provision(
    439                 &reference,
    440                 &SecretMaterial::from_slice(&[0x41; 32]).unwrap(),
    441                 Nonce::new([0x11; 24]),
    442             )
    443             .unwrap();
    444         let crypto = WorkspaceCrypto::new(
    445             vault.clone(),
    446             reference,
    447             SecretMaterial::from_slice(&[0x41; 32]).unwrap(),
    448             AccessPolicy::standard(),
    449         )
    450         .unwrap();
    451         let clock = Arc::new(Clock(AtomicU64::new(150), AtomicBool::new(false)));
    452         let control = Arc::new(Control::new());
    453         let provider = Arc::new(Provider {
    454             inner: LocalSigner::with_clock(
    455                 SecretKey::parse(&format!("{:064x}", 3)).unwrap(),
    456                 || Ok(150000),
    457             )
    458             .unwrap()
    459             .with_nonce_source(Arc::new(radroots_nostr::signing::OsNonceSource)),
    460             control: control.clone(),
    461         });
    462         let key = provider.inner.public_key();
    463         assert_eq!(key.to_hex(), data()["scope"]["seller"].as_str().unwrap());
    464         let enrollment = StockEnrollment::prepare(
    465             SellerStockConfig::new(
    466                 key,
    467                 key,
    468                 "synthetic-ordinary-acceptance",
    469                 UnixSeconds::new(expiry).unwrap(),
    470             )
    471             .unwrap(),
    472             clock.as_ref(),
    473         )
    474         .unwrap();
    475         let native = NativeWorkspace::initialize_seller_stock(
    476             &root.join("stock"),
    477             &enrollment,
    478             crypto,
    479             clock.clone(),
    480         )
    481         .await
    482         .unwrap();
    483         std::fs::create_dir(root.join("cache")).unwrap();
    484         let options = OpenOptions::new(
    485             Paths::from_directory(root.join("cache")).unwrap(),
    486             OpenMode::Create,
    487         )
    488         .with_source_generation(SourceGeneration::new([17; 32]).unwrap(), 1)
    489         .unwrap();
    490         let mut client =
    491             Client::open(NativeConfig::public_read(options).with_workspace(native.clone()))
    492                 .await
    493                 .unwrap();
    494         // Only IO is controlled. This preserves the actual client task host,
    495         // attached scopes, stock evidence owner and concrete native adapter.
    496         let mut io = Io::new(clock.clone());
    497         io.route_override = route;
    498         let io = Arc::new(io);
    499         client.session = client
    500             .session
    501             .clone()
    502             .with_command_runtime(Arc::new(CommandRuntime::new(io.clone())));
    503         let scope = client
    504             .attach(enrollment.input().clone(), proof(enrollment.proof()))
    505             .await
    506             .unwrap();
    507         let weak = Arc::downgrade(&provider);
    508         client
    509             .attach_signer(SignerHandle::new(provider, Arc::new(Callbacks)))
    510             .await
    511             .unwrap();
    512         client.start(StartMode::LocalOnly).await.unwrap();
    513         let rig = Self {
    514             vault,
    515             _temp: temp,
    516             client,
    517             native,
    518             enrollment,
    519             scope,
    520             clock,
    521             control,
    522             provider: weak,
    523             io,
    524         };
    525         rig.seed().await;
    526         rig
    527     }
    528     async fn minima(
    529         &self,
    530     ) -> (
    531         StockSourceCheckpointRef,
    532         StockListingCheckpointRef,
    533         InventoryCheckpointRef,
    534     ) {
    535         let current = self
    536             .native
    537             .stock_authority(self.enrollment.input().clone(), self.enrollment.proof())
    538             .await
    539             .unwrap();
    540         (
    541             current.source_checkpoint().unwrap(),
    542             current.listing_checkpoint().unwrap(),
    543             current.inventory_checkpoint().unwrap(),
    544         )
    545     }
    546     fn context(&self, id: u8) -> CommandContextData {
    547         self.scope
    548             .command_context(
    549                 OperationId::from_bytes([id; 32]),
    550                 None,
    551                 None,
    552                 UnixSeconds::new(230).unwrap(),
    553             )
    554             .unwrap()
    555             .data()
    556             .clone()
    557     }
    558     async fn seed(&self) {
    559         let value = data();
    560         let key = self.enrollment.input().participant();
    561         let raw = value["listing_raw"].as_str().unwrap();
    562         let listing: serde_json::Value = serde_json::from_str(raw).unwrap();
    563         let d = listing["tags"]
    564             .as_array()
    565             .unwrap()
    566             .iter()
    567             .find(|v| v[0] == "d")
    568             .unwrap()[1]
    569             .as_str()
    570             .unwrap();
    571         let mut head = ObservedHead::listing(key, d).unwrap();
    572         head.observe(raw).unwrap();
    573         let capture = StockListingCapture::prepare(
    574             SellerAuthoritySelection::from_attachment(self.enrollment.input()),
    575             &head,
    576         )
    577         .unwrap();
    578         let (_, minimum, _) = self.minima().await;
    579         self.native
    580             .retain_stock_listing(
    581                 self.scope.binding().clone(),
    582                 minimum,
    583                 &capture,
    584                 self.enrollment.proof(),
    585             )
    586             .await
    587             .unwrap();
    588         for row in value["sources"].as_array().unwrap() {
    589             let local = LocalSigner::with_clock(
    590                 SecretKey::parse(&format!(
    591                     "{:064x}",
    592                     row["recipient_scalar"].as_u64().unwrap()
    593                 ))
    594                 .unwrap(),
    595                 || Ok(1000),
    596             )
    597             .unwrap();
    598             let call = ProviderCall::new(
    599                 local.public_key(),
    600                 NonZeroU64::new(2000).unwrap(),
    601                 radroots_signing::request::CancellationSignal::new(),
    602             );
    603             let opened =
    604                 radroots_nostr::commerce::open(&local, call, row["raw_wrap"].as_str().unwrap())
    605                     .await
    606                     .unwrap();
    607             let capture = StockSourceCapture::prepare(
    608                 SellerAuthoritySelection::from_attachment(self.enrollment.input()),
    609                 &opened,
    610             )
    611             .unwrap();
    612             let (minimum, _, _) = self.minima().await;
    613             self.native
    614                 .retain_stock_source(
    615                     self.scope.binding().clone(),
    616                     minimum,
    617                     &capture,
    618                     self.enrollment.proof(),
    619                 )
    620                 .await
    621                 .unwrap();
    622         }
    623         let snapshot = self.request().await;
    624         let line = &snapshot.terms().lines()[0];
    625         for (id, wire) in [
    626             (
    627                 80,
    628                 serde_json::json!({"type":"stock.create_pool","context":self.context(80),"input":{"id":PoolId::from_bytes([80;32]),"label":"private test stock","unit":"each","tick_scale":"0","initial_quantity":"10"}}),
    629             ),
    630             (
    631                 81,
    632                 serde_json::json!({"type":"stock.map_option","context":self.context(81),"input":{"listing":line.source().coordinate(),"option_id":line.option_id(),"pool_id":PoolId::from_bytes([80;32]),"expected_mapping_version":"0","per_sale_unit":{"amount":"1","unit":"each"}}}),
    633             ),
    634         ] {
    635             assert_eq!(
    636                 wire["context"]["operation_id"],
    637                 serde_json::to_value(OperationId::from_bytes([id; 32])).unwrap()
    638             );
    639             let (_, _, minimum) = self.minima().await;
    640             let request = InventoryRequest::from_protected_wire(
    641                 self.scope.binding().clone(),
    642                 minimum,
    643                 &serde_json::to_vec(&wire).unwrap(),
    644             )
    645             .unwrap();
    646             assert!(matches!(
    647                 self.native
    648                     .execute_inventory(request, proof(self.enrollment.proof()))
    649                     .await
    650                     .unwrap(),
    651                 InventoryOutcome::Committed(_)
    652             ));
    653         }
    654     }
    655     async fn request(&self) -> StockRequestSnapshot {
    656         let (private, public, minimum) = self.minima().await;
    657         self.native
    658             .stock_order_request(
    659                 self.scope.binding().clone(),
    660                 minimum,
    661                 private,
    662                 public,
    663                 data()["request"].as_str().unwrap().parse().unwrap(),
    664                 self.enrollment.proof(),
    665             )
    666             .await
    667             .unwrap()
    668     }
    669     async fn captured(&self) -> (CapturedOrderAcceptance, CommandContext) {
    670         let snapshot = self.request().await;
    671         let mut value = serde_json::json!({"type":"orders.accept","context":self.context(90),"input":{"request":snapshot.request(),"terms_digest":snapshot.terms_digest(),"allocation":{"type":"automatic"}}});
    672         value["context"]["expected"] = serde_json::json!({"agreement":null,"buyer_head":snapshot.request(),"checkpoint":snapshot.checkpoint(),"order_id":snapshot.scope().order_id(),"seller_sequence":"0"});
    673         let first = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap();
    674         value["context"]["approval"] = serde_json::json!({"intent_digest":first.approval_intent_digest(),"scope":"orders.accept","expires_at":"230"});
    675         let command = CapturedOrderAcceptance::parse(&serde_json::to_vec(&value).unwrap()).unwrap();
    676         let context = self
    677             .scope
    678             .command_context(
    679                 command.context().operation_id(),
    680                 command.context().expected().cloned(),
    681                 command.context().approval().cloned(),
    682                 UnixSeconds::new(230).unwrap(),
    683             )
    684             .unwrap();
    685         let capture = StockConsentCapture::prepare(
    686             SellerAuthoritySelection::from_attachment(self.enrollment.input()),
    687             self.enrollment.input().grant_id(),
    688             StockConsentMode::ExecuteAndRecover,
    689             StockResources::all_pools(),
    690             UnixSeconds::new(230).unwrap(),
    691             CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(),
    692         )
    693         .unwrap();
    694         let (_, _, minimum) = self.minima().await;
    695         self.native
    696             .issue_stock_consent(
    697                 self.scope.binding().clone(),
    698                 minimum,
    699                 &capture,
    700                 self.enrollment.proof(),
    701             )
    702             .await
    703             .unwrap();
    704         (command, context)
    705     }
    706     async fn accept(&self) -> (CapturedOrderAcceptance, crate::orders::AcceptanceStatus) {
    707         let (command, context) = self.captured().await;
    708         let (private, public, minimum) = self.minima().await;
    709         let input = AcceptOrderInput::new(
    710             command.input().request(),
    711             command.input().terms_digest(),
    712             AllocationSelection::automatic(),
    713         );
    714         let status = self
    715             .client
    716             .orders(&self.scope)
    717             .accept(context, minimum, private, public, input)
    718             .await
    719             .unwrap();
    720         (command, status)
    721     }
    722 }
    723 
    724 #[tokio::test]
    725 async fn ordinary_acceptance_uses_real_t0_t1_s_t2_and_preserves_original_retry() {
    726     let r = Rig::new().await;
    727     let (command, status) = r.accept().await;
    728     assert!(status.installation().is_some());
    729     assert!(status.recipients().iter().all(|v| v.evidence.is_some()));
    730     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    731     assert_eq!(r.io.sent.lock().unwrap().len(), 2);
    732     let (_, _, minimum) = r.minima().await;
    733     let observed = r
    734         .client
    735         .orders(&r.scope)
    736         .acceptance_status(minimum, command.context().operation_id(), command.digest())
    737         .await
    738         .unwrap();
    739     assert_eq!(observed.installation(), status.installation());
    740     // Actual protected stock delivery uses controlled transport outcomes here.
    741     // S remains independently readable through the same native owner.
    742     assert!(observed.delivery().unwrap().iter().all(|value| {
    743         value.checkpoint() == observed.checkpoint()
    744             && value.source().is_some()
    745             && value.attempt_count() == 1
    746             && value.acceptance_satisfied().unwrap()
    747     }));
    748     let evidence = observed.recipients()[0].evidence.unwrap();
    749     let source = radroots_execution::session::commerce::AcceptanceStore::signing_evidence(
    750         &crate::native_commerce::NativeCommerce(Arc::new(r.native.clone())),
    751         radroots_execution::session::commerce::AcceptanceSelection {
    752             binding: r.scope.binding().clone(),
    753             minimum,
    754             operation: command.context().operation_id(),
    755             digest: command.digest(),
    756         },
    757         evidence,
    758         r.enrollment.proof(),
    759     )
    760     .await
    761     .unwrap()
    762     .unwrap();
    763     assert_eq!(source.receipt(), evidence);
    764     source.with_json(|raw| {
    765         assert_eq!(
    766             serde_json::from_str::<serde_json::Value>(raw).unwrap()["kind"],
    767             13
    768         )
    769     });
    770     r.clock.0.store(231, Ordering::SeqCst);
    771     let refused = r
    772         .client
    773         .orders(&r.scope)
    774         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
    775         .await
    776         .unwrap_err();
    777     assert_eq!(refused.code(), crate::Code::DeadlineExceeded);
    778     // Expired issuing consent is not silently renewed. An actual authorized
    779     // RecoverOnly replacement permits historical reads, never a new signature.
    780     let child = StockGrantEnrollment::prepare(
    781         &SellerAuthoritySelection::from_attachment(r.enrollment.input()),
    782         "replacement recovery operator".into(),
    783         UnixSeconds::new(290).unwrap(),
    784         StockGrantScope::full_inventory(),
    785     )
    786     .unwrap();
    787     r.native
    788         .enroll_stock_grant(
    789             r.scope.binding().clone(),
    790             minimum,
    791             r.enrollment.proof(),
    792             &child,
    793         )
    794         .await
    795         .unwrap();
    796     let (_, _, minimum) = r.minima().await;
    797     let capture = StockConsentCapture::prepare(
    798         SellerAuthoritySelection::from_attachment(r.enrollment.input()),
    799         child.input().grant_id(),
    800         StockConsentMode::RecoverOnly,
    801         StockResources::all_pools(),
    802         UnixSeconds::new(280).unwrap(),
    803         CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(),
    804     )
    805     .unwrap();
    806     r.native
    807         .issue_stock_consent(
    808             r.scope.binding().clone(),
    809             minimum,
    810             &capture,
    811             r.enrollment.proof(),
    812         )
    813         .await
    814         .unwrap();
    815     let recovery_scope = r
    816         .client
    817         .attach(child.input().clone(), proof(child.proof()))
    818         .await
    819         .unwrap();
    820     let resumed = r
    821         .client
    822         .orders(&recovery_scope)
    823         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
    824         .await
    825         .unwrap();
    826     assert_eq!(resumed.installation(), status.installation());
    827     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    828     assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0);
    829     r.client.close().await.unwrap();
    830     assert!(r.provider.upgrade().is_none());
    831 }
    832 
    833 #[tokio::test]
    834 async fn lost_observer_cannot_discard_actual_peer_artifact_and_close_installs_before_key_disposal()
    835 {
    836     let r = Rig::new().await;
    837     r.control.pause_peer.store(true, Ordering::SeqCst);
    838     let (command, context) = r.captured().await;
    839     let (private, public, minimum) = r.minima().await;
    840     let input = AcceptOrderInput::new(
    841         command.input().request(),
    842         command.input().terms_digest(),
    843         AllocationSelection::automatic(),
    844     );
    845     let client = r.client.clone();
    846     let scope = r.scope.clone();
    847     let waiter = tokio::spawn(async move {
    848         client
    849             .orders(&scope)
    850             .accept(context, minimum, private, public, input)
    851             .await
    852     });
    853     tokio::time::timeout(
    854         std::time::Duration::from_secs(20),
    855         r.control.entered.notified(),
    856     )
    857     .await
    858     .unwrap();
    859     assert_eq!(r.control.signs.load(Ordering::SeqCst), 1);
    860     waiter.abort();
    861     assert!(waiter.await.unwrap_err().is_cancelled());
    862     let mut closing = Box::pin(r.client.close());
    863     assert!(futures::poll!(closing.as_mut()).is_pending());
    864     assert!(r.provider.upgrade().is_some());
    865     r.control.release.notify_one();
    866     closing.await.unwrap();
    867     assert!(r.provider.upgrade().is_none());
    868     let crypto = WorkspaceCrypto::new(
    869         r.vault.clone(),
    870         SecretRef::new(
    871             SecretId::parse("workspace-key").unwrap(),
    872             BackendKind::File,
    873             KeyVersion::new(1).unwrap(),
    874         ),
    875         SecretMaterial::from_slice(&[0x41; 32]).unwrap(),
    876         AccessPolicy::standard(),
    877     )
    878     .unwrap();
    879     let reopened = NativeWorkspace::open_seller_stock(
    880         &r._temp.path().join("stock"),
    881         r.enrollment.input().clone(),
    882         crypto,
    883         r.clock.clone(),
    884     )
    885     .await
    886     .unwrap();
    887     let binding = reopened
    888         .authenticate(r.enrollment.input().clone(), r.enrollment.proof())
    889         .await
    890         .unwrap();
    891     let snapshot = reopened
    892         .stock_operation_snapshot(
    893             StockSnapshotRequest::new(
    894                 binding,
    895                 minimum,
    896                 command.context().operation_id(),
    897                 command.digest(),
    898             ),
    899             r.enrollment.proof(),
    900         )
    901         .await
    902         .unwrap();
    903     assert!(snapshot.installation().is_some());
    904     assert_eq!(
    905         snapshot
    906             .recipients()
    907             .iter()
    908             .filter(|v| v.first_evidence().is_some())
    909             .count(),
    910         1
    911     );
    912     assert_eq!(
    913         snapshot.preparation().attempt().operation_id(),
    914         command.context().operation_id()
    915     );
    916     assert_eq!(r.control.signs.load(Ordering::SeqCst), 1);
    917     reopened.close().await.unwrap();
    918 }
    919 
    920 #[path = "native_stock_delivery_tests.rs"]
    921 mod delivery;
    922 #[path = "native_refusal_tests.rs"]
    923 mod original_refusals;
    924 #[path = "native_stock_rewrap_tests.rs"]
    925 mod rewrap;
    926 
    927 #[path = "native_stock_deficit_tests.rs"]
    928 mod deficit;
    929 #[path = "native_stock_terms_tests.rs"]
    930 mod terms;
    931 
    932 #[tokio::test]
    933 async fn peer_installation_survives_self_refusal_and_resume_uses_original_exact_recovery() {
    934     let r = Rig::new().await;
    935     r.control.fail_self.store(true, Ordering::SeqCst);
    936     let (command, status) = r.accept().await;
    937     let installation = status
    938         .installation()
    939         .expect("peer S must install before self refusal");
    940     assert_eq!(
    941         status
    942             .recipients()
    943             .iter()
    944             .filter(|v| v.evidence.is_some())
    945             .count(),
    946         1
    947     );
    948     assert!(!status.aborted());
    949     assert_eq!(r.io.sent.lock().unwrap().len(), 1);
    950     for (delivery, recipient) in status.delivery().unwrap().iter().zip(status.recipients()) {
    951         assert_eq!(
    952             delivery.attempt_count(),
    953             u16::from(recipient.evidence.is_some())
    954         );
    955         assert_eq!(
    956             delivery.acceptance_satisfied().unwrap(),
    957             recipient.evidence.is_some()
    958         );
    959     }
    960     let original_refusal = status
    961         .recipients()
    962         .iter()
    963         .find_map(|v| v.original_unissued)
    964         .expect("actual original refusal must be captured");
    965     assert_eq!(original_refusal.reason, ProviderError::Cancelled);
    966     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    967     r.control.fail_self.store(false, Ordering::SeqCst);
    968     let (_, _, minimum) = r.minima().await;
    969     let resumed = r
    970         .client
    971         .orders(&r.scope)
    972         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
    973         .await
    974         .unwrap();
    975     assert_eq!(resumed.installation(), Some(installation));
    976     assert!(resumed.recipients().iter().all(|v| v.evidence.is_some()));
    977     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    978     assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1);
    979     assert_eq!(
    980         resumed
    981             .recipients()
    982             .iter()
    983             .find_map(|v| v.original_unissued),
    984         Some(original_refusal)
    985     );
    986     r.client.close().await.unwrap();
    987     assert!(r.provider.upgrade().is_none());
    988 }
    989 
    990 #[tokio::test]
    991 async fn later_local_capability_cannot_upgrade_an_original_non_replayable_unknown_claim() {
    992     let r = Rig::new().await;
    993     r.control.recovery_supported.store(false, Ordering::SeqCst);
    994     r.control.fail_self.store(true, Ordering::SeqCst);
    995     let (command, status) = r.accept().await;
    996     assert!(status.installation().is_some());
    997     r.control.fail_self.store(false, Ordering::SeqCst);
    998     r.control.recovery_supported.store(true, Ordering::SeqCst);
    999     let (_, _, minimum) = r.minima().await;
   1000     let resumed = r
   1001         .client
   1002         .orders(&r.scope)
   1003         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
   1004         .await
   1005         .unwrap();
   1006     assert_eq!(resumed.installation(), status.installation());
   1007     assert_eq!(
   1008         resumed
   1009             .recipients()
   1010             .iter()
   1011             .filter(|v| v.evidence.is_some())
   1012             .count(),
   1013         1
   1014     );
   1015     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
   1016     assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0);
   1017     assert!(!resumed.aborted());
   1018     r.client.close().await.unwrap();
   1019 }
   1020 
   1021 #[tokio::test]
   1022 async fn actual_s_insert_failure_retains_obtained_peer_bytes_and_resumes_without_peer_reissue() {
   1023     use sqlx::Connection;
   1024     let r = Rig::new().await;
   1025     r.control.pause_peer.store(true, Ordering::SeqCst);
   1026     let (command, context) = r.captured().await;
   1027     let (private, public, minimum) = r.minima().await;
   1028     let input = AcceptOrderInput::new(
   1029         command.input().request(),
   1030         command.input().terms_digest(),
   1031         AllocationSelection::automatic(),
   1032     );
   1033     let client = r.client.clone();
   1034     let scope = r.scope.clone();
   1035     let waiter = tokio::spawn(async move {
   1036         client
   1037             .orders(&scope)
   1038             .accept(context, minimum, private, public, input)
   1039             .await
   1040     });
   1041     tokio::time::timeout(
   1042         std::time::Duration::from_secs(20),
   1043         r.control.entered.notified(),
   1044     )
   1045     .await
   1046     .unwrap();
   1047     // The real peer artifact already exists. Fail the actual SQL INSERT,
   1048     // independently of Core's retained-material owner and transaction result.
   1049     let path = r._temp.path().join("stock/stock_execution_v1.sqlite");
   1050     let mut fault = sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display()))
   1051         .await
   1052         .unwrap();
   1053     sqlx::query("CREATE TRIGGER controlled_s_failure BEFORE INSERT ON stock_signing_evidence BEGIN SELECT RAISE(ABORT, 'controlled_s_failure'); END").execute(&mut fault).await.unwrap();
   1054     r.control.release.notify_one();
   1055     let error = waiter.await.unwrap().unwrap_err();
   1056     assert_eq!(error.code(), crate::Code::StorageFailure);
   1057     assert_eq!(error.context().admission(), crate::Admission::Confirmed);
   1058     assert_eq!(r.control.signs.load(Ordering::SeqCst), 1);
   1059     let context = r
   1060         .scope
   1061         .command_context(
   1062             command.context().operation_id(),
   1063             command.context().expected().cloned(),
   1064             command.context().approval().cloned(),
   1065             UnixSeconds::new(230).unwrap(),
   1066         )
   1067         .unwrap();
   1068     let blocked = r
   1069         .client
   1070         .orders(&r.scope)
   1071         .accept(
   1072             context,
   1073             minimum,
   1074             private,
   1075             public,
   1076             AcceptOrderInput::new(
   1077                 command.input().request(),
   1078                 command.input().terms_digest(),
   1079                 AllocationSelection::automatic(),
   1080             ),
   1081         )
   1082         .await
   1083         .unwrap_err();
   1084     assert_eq!(blocked.code(), crate::Code::RecoveryRequired);
   1085     assert_eq!(r.control.signs.load(Ordering::SeqCst), 1);
   1086     sqlx::query("DROP TRIGGER controlled_s_failure")
   1087         .execute(&mut fault)
   1088         .await
   1089         .unwrap();
   1090     fault.close().await.unwrap();
   1091     r.client.stock(&r.scope).drain_evidence().await.unwrap();
   1092     let status = r
   1093         .client
   1094         .orders(&r.scope)
   1095         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
   1096         .await
   1097         .unwrap();
   1098     assert!(status.installation().is_some());
   1099     assert!(status.recipients().iter().all(|v| v.evidence.is_some()));
   1100     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
   1101     assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 0);
   1102     let pool = r
   1103         .native
   1104         .pool(
   1105             r.scope.binding().clone(),
   1106             status.checkpoint(),
   1107             PoolId::from_bytes([80; 32]),
   1108             proof(r.enrollment.proof()),
   1109         )
   1110         .await
   1111         .unwrap()
   1112         .unwrap();
   1113     assert_eq!(pool.snapshot().balances().physical().available.get(), 7);
   1114     assert_eq!(
   1115         pool.snapshot().balances().physical().preparatory_hold.get(),
   1116         0
   1117     );
   1118     assert_eq!(
   1119         pool.snapshot().balances().physical().committed_hold.get(),
   1120         3
   1121     );
   1122     r.client.close().await.unwrap();
   1123     assert!(r.provider.upgrade().is_none());
   1124 }
   1125 
   1126 #[tokio::test]
   1127 async fn identical_authenticated_foreign_scope_cannot_start_this_clients_acceptance() {
   1128     let r = Rig::new().await;
   1129     let (command, _) = r.captured().await;
   1130     let (private, public, minimum) = r.minima().await;
   1131     let path = r._temp.path().join("other_cache");
   1132     std::fs::create_dir(&path).unwrap();
   1133     let options = OpenOptions::new(Paths::from_directory(path).unwrap(), OpenMode::Create)
   1134         .with_source_generation(SourceGeneration::new([19; 32]).unwrap(), 1)
   1135         .unwrap();
   1136     let other = Client::open(NativeConfig::public_read(options).with_workspace(r.native.clone()))
   1137         .await
   1138         .unwrap();
   1139     let foreign = other
   1140         .attach(r.enrollment.input().clone(), proof(r.enrollment.proof()))
   1141         .await
   1142         .unwrap();
   1143     assert_eq!(foreign.binding().input(), r.scope.binding().input());
   1144     let context = foreign
   1145         .command_context(
   1146             command.context().operation_id(),
   1147             command.context().expected().cloned(),
   1148             command.context().approval().cloned(),
   1149             UnixSeconds::new(230).unwrap(),
   1150         )
   1151         .unwrap();
   1152     assert_eq!(context.data(), command.context());
   1153     let error = r
   1154         .client
   1155         .orders(&foreign)
   1156         .accept(
   1157             context,
   1158             minimum,
   1159             private,
   1160             public,
   1161             AcceptOrderInput::new(
   1162                 command.input().request(),
   1163                 command.input().terms_digest(),
   1164                 AllocationSelection::automatic(),
   1165             ),
   1166         )
   1167         .await
   1168         .unwrap_err();
   1169     assert_eq!(error.code(), crate::Code::Unauthorized);
   1170     assert_eq!(error.context().admission(), crate::Admission::NotAdmitted);
   1171     assert_eq!(r.minima().await.2, minimum);
   1172     assert_eq!(r.control.signs.load(Ordering::SeqCst), 0);
   1173     r.client.close().await.unwrap();
   1174     other.close().await.unwrap();
   1175 }
   1176 
   1177 fn assert_rejected(error: crate::ExecutionFailure, operation: OperationId, control: &Control) {
   1178     assert_eq!(error.code(), crate::Code::SignerTampering);
   1179     assert_eq!(error.context().operation_id(), Some(operation));
   1180     assert_eq!(error.context().admission(), crate::Admission::Confirmed);
   1181     assert_eq!(error.retry(), crate::RetryClass::ManualReconciliation);
   1182     let rejected = error
   1183         .signer_rejection()
   1184         .expect("preserve the actual bounded rejection");
   1185     assert_eq!(
   1186         rejected,
   1187         *control.rejected.lock().unwrap().as_ref().unwrap()
   1188     );
   1189     let fingerprint = rejected
   1190         .fingerprint()
   1191         .expect("actual returned bytes have fingerprint coverage");
   1192     assert!(fingerprint.covered_bytes() > 0);
   1193     assert_eq!(fingerprint.covered_bytes(), fingerprint.total_bytes());
   1194     assert!(fingerprint.covered_bytes() <= 65536);
   1195 }
   1196 
   1197 #[tokio::test]
   1198 async fn rejected_self_callback_returns_bounded_tampering_without_losing_peer_installation() {
   1199     let r = Rig::new().await;
   1200     r.control.tamper_self.store(true, Ordering::SeqCst);
   1201     let (command, context) = r.captured().await;
   1202     let (private, public, minimum) = r.minima().await;
   1203     let error = r
   1204         .client
   1205         .orders(&r.scope)
   1206         .accept(
   1207             context,
   1208             minimum,
   1209             private,
   1210             public,
   1211             AcceptOrderInput::new(
   1212                 command.input().request(),
   1213                 command.input().terms_digest(),
   1214                 AllocationSelection::automatic(),
   1215             ),
   1216         )
   1217         .await
   1218         .unwrap_err();
   1219     assert_rejected(error, command.context().operation_id(), &r.control);
   1220     let status = r
   1221         .client
   1222         .orders(&r.scope)
   1223         .acceptance_status(minimum, command.context().operation_id(), command.digest())
   1224         .await
   1225         .unwrap();
   1226     let installed = status
   1227         .installation()
   1228         .expect("actual peer S installs before self rejection");
   1229     assert_eq!(
   1230         status
   1231             .recipients()
   1232             .iter()
   1233             .filter(|v| v.evidence.is_some())
   1234             .count(),
   1235         1
   1236     );
   1237     assert!(!status.aborted());
   1238     assert_eq!(r.io.sent.lock().unwrap().len(), 1);
   1239     for (delivery, recipient) in status.delivery().unwrap().iter().zip(status.recipients()) {
   1240         assert_eq!(
   1241             delivery.attempt_count(),
   1242             u16::from(recipient.evidence.is_some())
   1243         );
   1244         assert_eq!(
   1245             delivery.acceptance_satisfied().unwrap(),
   1246             recipient.evidence.is_some()
   1247         );
   1248     }
   1249     r.control.tamper_self.store(false, Ordering::SeqCst);
   1250     let resumed = r
   1251         .client
   1252         .orders(&r.scope)
   1253         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
   1254         .await
   1255         .unwrap();
   1256     assert_eq!(resumed.installation(), Some(installed));
   1257     assert!(resumed.recipients().iter().all(|v| v.evidence.is_some()));
   1258     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
   1259     assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1);
   1260     r.client.close().await.unwrap();
   1261     assert!(r.provider.upgrade().is_none());
   1262 }
   1263 
   1264 #[tokio::test]
   1265 async fn generic_inquiry_installs_actual_peer_and_returns_original_bounded_self_rejection() {
   1266     for fail_install in [false, true] {
   1267         let r = Rig::new().await;
   1268         r.control
   1269             .pause_rejected
   1270             .store(fail_install, Ordering::SeqCst);
   1271         r.control.tamper_self.store(true, Ordering::SeqCst);
   1272         let crypto = WorkspaceCrypto::new(
   1273             r.vault.clone(),
   1274             SecretRef::new(
   1275                 SecretId::parse("workspace-key").unwrap(),
   1276                 BackendKind::File,
   1277                 KeyVersion::new(1).unwrap(),
   1278             ),
   1279             SecretMaterial::from_slice(&[0x41; 32]).unwrap(),
   1280             AccessPolicy::standard(),
   1281         )
   1282         .unwrap();
   1283         let key = r.enrollment.input().participant();
   1284         let (native, input, credential) = NativeWorkspace::initialize_local_outbox(
   1285             &r._temp.path().join("chat"),
   1286             radroots_storage_sqlite::workspace::LocalOutboxConfig::new(
   1287                 key,
   1288                 key,
   1289                 "synthetic-rejected-chat",
   1290                 UnixSeconds::new(300).unwrap(),
   1291             )
   1292             .unwrap(),
   1293             crypto,
   1294             r.clock.clone(),
   1295         )
   1296         .await
   1297         .unwrap();
   1298         let path = r._temp.path().join("chat_cache");
   1299         std::fs::create_dir(&path).unwrap();
   1300         let options = OpenOptions::new(Paths::from_directory(path).unwrap(), OpenMode::Create)
   1301             .with_source_generation(SourceGeneration::new([20; 32]).unwrap(), 1)
   1302             .unwrap();
   1303         let mut client = Client::open(NativeConfig::public_read(options).with_workspace(native))
   1304             .await
   1305             .unwrap();
   1306         client.session =
   1307             client
   1308                 .session
   1309                 .clone()
   1310                 .with_command_runtime(Arc::new(CommandRuntime::new(Arc::new(Io::new(
   1311                     r.clock.clone(),
   1312                 )))));
   1313         let scope = client.attach(input, proof(&credential)).await.unwrap();
   1314         client
   1315             .attach_signer(SignerHandle::new(
   1316                 r.provider.upgrade().unwrap(),
   1317                 Arc::new(Callbacks),
   1318             ))
   1319             .await
   1320             .unwrap();
   1321         client.start(StartMode::LocalOnly).await.unwrap();
   1322         let operation = OperationId::from_bytes([95; 32]);
   1323         let context = scope
   1324             .command_context(operation, None, None, UnixSeconds::new(230).unwrap())
   1325             .unwrap();
   1326         let peer = data()["scope"]["buyer"].as_str().unwrap().parse().unwrap();
   1327         let input = crate::inbox::InquireInput::new(
   1328             radroots_domain::ThreadId::from_bytes([96; 32]),
   1329             peer,
   1330             None,
   1331             "synthetic private inquiry",
   1332         )
   1333         .unwrap();
   1334         let observer_client = client.clone();
   1335         let observer =
   1336             tokio::spawn(async move { observer_client.inbox().inquire(context, input).await });
   1337         let mut injected = None;
   1338         if fail_install {
   1339             use sqlx::Connection;
   1340             tokio::time::timeout(
   1341                 std::time::Duration::from_secs(20),
   1342                 r.control.entered.notified(),
   1343             )
   1344             .await
   1345             .unwrap();
   1346             let path = r._temp.path().join("chat/execution_v1.sqlite");
   1347             let mut connection =
   1348                 sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display()))
   1349                     .await
   1350                     .unwrap();
   1351             sqlx::query("CREATE TRIGGER controlled_t2_failure BEFORE INSERT ON chat_messages BEGIN SELECT RAISE(ABORT, 'controlled_t2_failure'); END").execute(&mut connection).await.unwrap();
   1352             injected = Some(connection);
   1353             r.control.release.notify_one();
   1354         }
   1355         let error = observer.await.unwrap().unwrap_err();
   1356         if fail_install {
   1357             assert_eq!(error.code(), crate::Code::StorageFailure);
   1358             assert_eq!(error.context().operation_id(), Some(operation));
   1359             assert_eq!(error.context().admission(), crate::Admission::Confirmed);
   1360             assert_eq!(error.retry(), crate::RetryClass::ManualReconciliation);
   1361             assert_eq!(
   1362                 error.signer_rejection(),
   1363                 *r.control.rejected.lock().unwrap()
   1364             );
   1365         } else {
   1366             assert_rejected(error, operation, &r.control)
   1367         }
   1368         if let Some(mut connection) = injected {
   1369             use sqlx::Connection;
   1370             sqlx::query("DROP TRIGGER controlled_t2_failure")
   1371                 .execute(&mut connection)
   1372                 .await
   1373                 .unwrap();
   1374             connection.close().await.unwrap();
   1375         }
   1376         let status = client
   1377             .operations(&scope)
   1378             .get(operation)
   1379             .await
   1380             .unwrap()
   1381             .unwrap();
   1382         assert_eq!(
   1383             status.business_installation(),
   1384             if fail_install {
   1385                 crate::BusinessInstallation::NotInstalled
   1386             } else {
   1387                 crate::BusinessInstallation::Installed
   1388             }
   1389         );
   1390         assert_eq!(
   1391             status
   1392                 .artifacts()
   1393                 .iter()
   1394                 .filter(|v| v.issuance() == crate::Issuance::Obtained)
   1395                 .count(),
   1396             1
   1397         );
   1398         assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
   1399         client.close().await.unwrap();
   1400         r.client.close().await.unwrap();
   1401         assert!(r.provider.upgrade().is_none());
   1402     }
   1403 }
   1404 
   1405 #[tokio::test]
   1406 async fn rejected_exact_recovery_keeps_original_binding_and_cannot_release_installed_peer() {
   1407     let r = Rig::new().await;
   1408     r.control.fail_self.store(true, Ordering::SeqCst);
   1409     let (command, status) = r.accept().await;
   1410     let installed = status.installation().unwrap();
   1411     r.control.fail_self.store(false, Ordering::SeqCst);
   1412     r.control.tamper_recovery.store(true, Ordering::SeqCst);
   1413     let (_, _, minimum) = r.minima().await;
   1414     let error = r
   1415         .client
   1416         .orders(&r.scope)
   1417         .resume_acceptance(minimum, command.context().operation_id(), command.digest())
   1418         .await
   1419         .unwrap_err();
   1420     assert_rejected(error, command.context().operation_id(), &r.control);
   1421     let current = r
   1422         .client
   1423         .orders(&r.scope)
   1424         .acceptance_status(minimum, command.context().operation_id(), command.digest())
   1425         .await
   1426         .unwrap();
   1427     assert_eq!(current.installation(), Some(installed));
   1428     assert_eq!(
   1429         current
   1430             .recipients()
   1431             .iter()
   1432             .filter(|v| v.evidence.is_some())
   1433             .count(),
   1434         1
   1435     );
   1436     assert!(!current.aborted());
   1437     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
   1438     assert_eq!(r.control.recoveries.load(Ordering::SeqCst), 1);
   1439     r.client.close().await.unwrap();
   1440 }