lib

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

signer_session.rs (28956B)


      1 #![cfg(feature = "signer_session")]
      2 
      3 use core::task::Poll;
      4 #[cfg(not(target_arch = "wasm32"))]
      5 use core::{future::Future, pin::pin, task::Context};
      6 #[cfg(not(target_arch = "wasm32"))]
      7 use futures::task::noop_waker_ref;
      8 use futures::{channel::oneshot, executor::block_on, task::AtomicWaker};
      9 use radroots_execution::session::{SessionState, SignerSession};
     10 use radroots_identity::PublicKey;
     11 use radroots_signing::host::Shared;
     12 use radroots_signing::{
     13     SignReceipt, SignRequest, Signer, SignerStatus,
     14     provider::{
     15         ParticipantProvider, PrivateCiphertext, PrivateCryptoCapability, PrivateText, ProviderCall,
     16         ProviderError, ProviderState, SignerCallbacks, SignerHandle,
     17     },
     18     recovery::ReplayCapability,
     19     signer::BoxFuture,
     20 };
     21 use std::sync::{
     22     Mutex,
     23     atomic::{AtomicBool, AtomicUsize, Ordering},
     24 };
     25 #[cfg(all(feature = "commerce", not(target_arch = "wasm32")))]
     26 #[path = "support/signer_commerce.rs"]
     27 mod commerce;
     28 #[cfg(not(target_arch = "wasm32"))]
     29 #[path = "support/signer_recovery.rs"]
     30 mod recovery;
     31 
     32 fn key(second: bool) -> PublicKey {
     33     PublicKey::from_hex(if second {
     34         "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"
     35     } else {
     36         "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
     37     })
     38     .unwrap()
     39 }
     40 
     41 fn state(second: bool, encrypt: bool) -> ProviderState {
     42     ProviderState::new(
     43         key(second),
     44         if encrypt {
     45             PrivateCryptoCapability::Nip44V2
     46         } else {
     47             PrivateCryptoCapability::Unavailable
     48         },
     49         PrivateCryptoCapability::Nip44V2,
     50         ReplayCapability::NonReplayable,
     51     )
     52 }
     53 
     54 struct Control {
     55     commerce_plaintext: Mutex<Option<String>>,
     56     recovery_calls: AtomicUsize,
     57     recovery_response:
     58         Mutex<Option<oneshot::Receiver<radroots_signing::issuance::ExactRecoveryOutcome>>>,
     59     recovery_binding: Mutex<Option<radroots_signing::issuance::IntentBinding>>,
     60     current: Mutex<ProviderState>,
     61     calls: AtomicUsize,
     62     sign_calls: AtomicUsize,
     63     crypto_calls: AtomicUsize,
     64     crypto_response: Mutex<Option<oneshot::Receiver<()>>>,
     65     sign_response: Mutex<Option<oneshot::Receiver<radroots_signing::issuance::SigningOutcome>>>,
     66     sign_binding: Mutex<Option<radroots_signing::issuance::IntentBinding>>,
     67     response: Mutex<Option<oneshot::Receiver<()>>>,
     68     quiesces: AtomicUsize,
     69     quiesced: AtomicBool,
     70     close_attempts: AtomicUsize,
     71     closes: AtomicUsize,
     72     close_ready: AtomicBool,
     73     fail_close_once: AtomicBool,
     74     wake: AtomicWaker,
     75     #[cfg(target_arch = "wasm32")]
     76     _local: std::rc::Rc<std::cell::Cell<u8>>,
     77 }
     78 
     79 struct Provider(Shared<Control>);
     80 struct Callbacks(Shared<Control>);
     81 
     82 impl Signer for Provider {
     83     fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> {
     84         Box::pin(async { Ok(SignerStatus::unavailable()) })
     85     }
     86     fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> {
     87         Box::pin(async {
     88             Err(radroots_signing::Error::new(
     89                 radroots_signing::error::Kind::SignerUnavailable,
     90             ))
     91         })
     92     }
     93 }
     94 
     95 impl ParticipantProvider for Provider {
     96     fn recover_exact(
     97         &self,
     98         request: radroots_signing::issuance::ExactRecoveryRequest,
     99     ) -> BoxFuture<'_, radroots_signing::issuance::ExactRecoveryOutcome> {
    100         use radroots_signing::issuance::ExactRecoveryOutcome;
    101         Box::pin(async move {
    102             self.0.recovery_calls.fetch_add(1, Ordering::SeqCst);
    103             let binding = self
    104                 .0
    105                 .recovery_binding
    106                 .lock()
    107                 .unwrap()
    108                 .unwrap_or(request.binding());
    109             let response = self.0.recovery_response.lock().unwrap().take();
    110             if let Some(response) = response {
    111                 response.await.unwrap_or_else(|_| {
    112                     ExactRecoveryOutcome::indeterminate(binding, ProviderError::ProviderFailure)
    113                 })
    114             } else {
    115                 ExactRecoveryOutcome::indeterminate(binding, ProviderError::ProviderFailure)
    116             }
    117         })
    118     }
    119     fn sign_exact(
    120         &self,
    121         intent: radroots_signing::issuance::SigningIntent,
    122     ) -> BoxFuture<'_, radroots_signing::issuance::SigningOutcome> {
    123         use radroots_signing::issuance::SigningOutcome;
    124         Box::pin(async move {
    125             self.0.sign_calls.fetch_add(1, Ordering::SeqCst);
    126             let binding = self
    127                 .0
    128                 .sign_binding
    129                 .lock()
    130                 .unwrap()
    131                 .unwrap_or(intent.binding());
    132             let response = self.0.sign_response.lock().unwrap().take();
    133             if let Some(response) = response {
    134                 response.await.unwrap_or_else(|_| {
    135                     SigningOutcome::unknown(binding, ProviderError::ProviderFailure)
    136                 })
    137             } else {
    138                 SigningOutcome::unknown(binding, ProviderError::ProviderFailure)
    139             }
    140         })
    141     }
    142 
    143     fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> {
    144         Box::pin(async move {
    145             self.0.calls.fetch_add(1, Ordering::SeqCst);
    146             let response = self.0.response.lock().unwrap().take();
    147             if let Some(response) = response {
    148                 response.await.map_err(|_| ProviderError::Cancelled)?;
    149             }
    150             if self.0.quiesced.load(Ordering::SeqCst) {
    151                 return Err(ProviderError::Cancelled);
    152             }
    153             Ok(*self.0.current.lock().unwrap())
    154         })
    155     }
    156     fn encrypt_private(
    157         &self,
    158         _: ProviderCall,
    159         _: PublicKey,
    160         _: PrivateText,
    161     ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> {
    162         Box::pin(async move {
    163             self.0.crypto_calls.fetch_add(1, Ordering::SeqCst);
    164             let response = self.0.crypto_response.lock().unwrap().take();
    165             if let Some(response) = response {
    166                 response.await.map_err(|_| ProviderError::Cancelled)?;
    167             }
    168             Err(ProviderError::ProviderFailure)
    169         })
    170     }
    171     fn decrypt_private(
    172         &self,
    173         _: ProviderCall,
    174         _: PublicKey,
    175         _: PrivateCiphertext,
    176     ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> {
    177         Box::pin(async move {
    178             self.0.crypto_calls.fetch_add(1, Ordering::SeqCst);
    179             let response = self.0.crypto_response.lock().unwrap().take();
    180             if let Some(response) = response {
    181                 response.await.map_err(|_| ProviderError::Cancelled)?;
    182             }
    183             self.0
    184                 .commerce_plaintext
    185                 .lock()
    186                 .unwrap()
    187                 .as_deref()
    188                 .map(PrivateText::new)
    189                 .unwrap_or(Err(ProviderError::ProviderFailure))
    190         })
    191     }
    192 }
    193 
    194 impl SignerCallbacks for Callbacks {
    195     fn quiesce(&self) -> BoxFuture<'_, Result<(), ProviderError>> {
    196         Box::pin(async move {
    197             self.0.quiesces.fetch_add(1, Ordering::SeqCst);
    198             self.0.quiesced.store(true, Ordering::SeqCst);
    199             Ok(())
    200         })
    201     }
    202     fn close(&self) -> BoxFuture<'_, Result<(), ProviderError>> {
    203         Box::pin(async move {
    204             self.0.close_attempts.fetch_add(1, Ordering::SeqCst);
    205             if self.0.fail_close_once.swap(false, Ordering::SeqCst) {
    206                 return Err(ProviderError::CapabilityUnavailable);
    207             }
    208             core::future::poll_fn(|cx| {
    209                 self.0.wake.register(cx.waker());
    210                 if self.0.close_ready.load(Ordering::SeqCst) {
    211                     Poll::Ready(())
    212                 } else {
    213                     Poll::Pending
    214                 }
    215             })
    216             .await;
    217             self.0.closes.fetch_add(1, Ordering::SeqCst);
    218             Ok(())
    219         })
    220     }
    221 }
    222 
    223 #[cfg(not(target_arch = "wasm32"))]
    224 struct Fixture {
    225     session: SignerSession,
    226     control: Shared<Control>,
    227     provider: std::sync::Weak<Provider>,
    228     callbacks: std::sync::Weak<Callbacks>,
    229 }
    230 
    231 #[cfg(not(target_arch = "wasm32"))]
    232 fn scope() -> Fixture {
    233     // Native weak handles make root release independently observable.
    234     let control = control();
    235     let provider = Shared::new(Provider(control.clone()));
    236     let callbacks = Shared::new(Callbacks(control.clone()));
    237     let weak_provider = Shared::downgrade(&provider);
    238     let weak_callbacks = Shared::downgrade(&callbacks);
    239     Fixture {
    240         session: SignerSession::new(SignerHandle::new(provider, callbacks)),
    241         control,
    242         provider: weak_provider,
    243         callbacks: weak_callbacks,
    244     }
    245 }
    246 
    247 fn control() -> Shared<Control> {
    248     Shared::new(Control {
    249         commerce_plaintext: Mutex::new(None),
    250         recovery_calls: AtomicUsize::new(0),
    251         recovery_response: Mutex::new(None),
    252         recovery_binding: Mutex::new(None),
    253         current: Mutex::new(state(false, false)),
    254         calls: AtomicUsize::new(0),
    255         sign_calls: AtomicUsize::new(0),
    256         crypto_calls: AtomicUsize::new(0),
    257         crypto_response: Mutex::new(None),
    258         sign_response: Mutex::new(None),
    259         sign_binding: Mutex::new(None),
    260         response: Mutex::new(None),
    261         quiesces: AtomicUsize::new(0),
    262         quiesced: AtomicBool::new(false),
    263         close_attempts: AtomicUsize::new(0),
    264         closes: AtomicUsize::new(0),
    265         close_ready: AtomicBool::new(true),
    266         fail_close_once: AtomicBool::new(false),
    267         wake: AtomicWaker::new(),
    268         #[cfg(target_arch = "wasm32")]
    269         _local: std::rc::Rc::new(std::cell::Cell::new(0)),
    270     })
    271 }
    272 
    273 #[cfg(not(target_arch = "wasm32"))]
    274 #[test]
    275 fn construction_is_inert_and_clones_share_identity_and_revocation() {
    276     let Fixture {
    277         session,
    278         control,
    279         provider,
    280         callbacks,
    281     } = scope();
    282     assert_eq!(session.state(), SessionState::Ready);
    283     assert!(session.observed().is_none());
    284     assert_eq!(control.calls.load(Ordering::SeqCst), 0);
    285     assert_eq!(control.quiesces.load(Ordering::SeqCst), 0);
    286     let close = session.close();
    287     drop(close);
    288     assert_eq!(session.state(), SessionState::Ready);
    289     let clone = session.clone();
    290     assert_eq!(block_on(session.observe()).unwrap().identity(), key(false));
    291     *control.current.lock().unwrap() = state(false, true);
    292     assert_eq!(
    293         block_on(clone.observe()).unwrap().encryption(),
    294         PrivateCryptoCapability::Nip44V2
    295     );
    296     *control.current.lock().unwrap() = state(true, false);
    297     assert_eq!(
    298         block_on(session.observe()),
    299         Err(ProviderError::IdentityChanged)
    300     );
    301     assert_eq!(session.observed().unwrap().identity(), key(false));
    302     assert!(session.identity_changed());
    303     *control.current.lock().unwrap() = state(false, false);
    304     assert_eq!(
    305         block_on(session.observe()),
    306         Err(ProviderError::IdentityChanged)
    307     );
    308     assert_eq!(control.calls.load(Ordering::SeqCst), 3);
    309     block_on(clone.close()).unwrap();
    310     assert_eq!(session.state(), SessionState::Closed);
    311     assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none());
    312     assert_eq!(
    313         block_on(session.observe()),
    314         Err(ProviderError::CapabilityUnavailable)
    315     );
    316     block_on(session.close()).unwrap();
    317     assert_eq!(control.quiesces.load(Ordering::SeqCst), 1);
    318     assert_eq!(control.closes.load(Ordering::SeqCst), 1);
    319 }
    320 
    321 #[cfg(not(target_arch = "wasm32"))]
    322 #[test]
    323 fn close_before_observation_disposes_roots_without_querying_identity() {
    324     let Fixture {
    325         session,
    326         control,
    327         provider,
    328         callbacks,
    329     } = scope();
    330     block_on(session.close()).unwrap();
    331     assert_eq!(control.calls.load(Ordering::SeqCst), 0);
    332     assert_eq!(control.quiesces.load(Ordering::SeqCst), 1);
    333     assert_eq!(control.closes.load(Ordering::SeqCst), 1);
    334     assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none());
    335     assert!(session.observed().is_none());
    336     assert_eq!(session.state(), SessionState::Closed);
    337 }
    338 
    339 #[cfg(not(target_arch = "wasm32"))]
    340 #[test]
    341 fn close_quiesces_before_draining_and_retains_inflight_roots() {
    342     let Fixture {
    343         session,
    344         control,
    345         provider,
    346         ..
    347     } = scope();
    348     let (send, receive) = oneshot::channel();
    349     *control.response.lock().unwrap() = Some(receive);
    350     let mut observe = pin!(session.observe());
    351     let mut cx = Context::from_waker(noop_waker_ref());
    352     assert!(observe.as_mut().poll(&mut cx).is_pending());
    353     assert_eq!(
    354         block_on(session.observe()),
    355         Err(ProviderError::CapabilityUnavailable)
    356     );
    357     assert_eq!(control.calls.load(Ordering::SeqCst), 1);
    358     let mut close = pin!(session.close());
    359     assert!(close.as_mut().poll(&mut cx).is_pending());
    360     assert_eq!(control.quiesces.load(Ordering::SeqCst), 1);
    361     assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0);
    362     assert!(provider.upgrade().is_some());
    363     send.send(()).unwrap();
    364     assert_eq!(
    365         observe.as_mut().poll(&mut cx),
    366         Poll::Ready(Err(ProviderError::Cancelled))
    367     );
    368     assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(()))));
    369     assert!(provider.upgrade().is_none());
    370     assert!(session.observed().is_none());
    371 }
    372 
    373 #[cfg(not(target_arch = "wasm32"))]
    374 #[test]
    375 fn failed_and_cancelled_callback_disposal_keep_the_unfinished_stage() {
    376     for fail in [false, true] {
    377         let Fixture {
    378             session,
    379             control,
    380             provider,
    381             callbacks,
    382         } = scope();
    383         block_on(session.observe()).unwrap();
    384         if fail {
    385             control.fail_close_once.store(true, Ordering::SeqCst);
    386             assert!(block_on(session.close()).is_err());
    387         } else {
    388             control.close_ready.store(false, Ordering::SeqCst);
    389             let mut close = Box::pin(session.close());
    390             assert!(
    391                 close
    392                     .as_mut()
    393                     .poll(&mut Context::from_waker(noop_waker_ref()))
    394                     .is_pending()
    395             );
    396             drop(close);
    397         }
    398         assert_eq!(session.state(), SessionState::Closing);
    399         assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some());
    400         control.close_ready.store(true, Ordering::SeqCst);
    401         control.wake.wake();
    402         block_on(session.close()).unwrap();
    403         assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none());
    404         assert_eq!(control.quiesces.load(Ordering::SeqCst), 1);
    405         assert_eq!(control.close_attempts.load(Ordering::SeqCst), 2);
    406         assert_eq!(control.closes.load(Ordering::SeqCst), 1);
    407     }
    408 }
    409 
    410 #[cfg(not(target_arch = "wasm32"))]
    411 #[test]
    412 fn failed_observation_does_not_freeze_a_key_and_lost_observer_keeps_host_roots() {
    413     let Fixture {
    414         session,
    415         control,
    416         provider,
    417         callbacks,
    418     } = scope();
    419     let (send, receive) = oneshot::channel();
    420     drop(send);
    421     *control.response.lock().unwrap() = Some(receive);
    422     assert_eq!(block_on(session.observe()), Err(ProviderError::Cancelled));
    423     assert!(session.observed().is_none());
    424     *control.current.lock().unwrap() = state(true, false);
    425     assert_eq!(block_on(session.observe()).unwrap().identity(), key(true));
    426 
    427     let (send, receive) = oneshot::channel();
    428     *control.response.lock().unwrap() = Some(receive);
    429     let mut observe = Box::pin(session.observe());
    430     let mut cx = Context::from_waker(noop_waker_ref());
    431     assert!(observe.as_mut().poll(&mut cx).is_pending());
    432     drop(observe);
    433     control.close_ready.store(false, Ordering::SeqCst);
    434     let mut close = Box::pin(session.close());
    435     assert!(close.as_mut().poll(&mut cx).is_pending());
    436     assert_eq!(control.close_attempts.load(Ordering::SeqCst), 1);
    437     assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some());
    438     assert!(send.send(()).is_err());
    439     control.close_ready.store(true, Ordering::SeqCst);
    440     control.wake.wake();
    441     assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(()))));
    442     assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none());
    443 }
    444 
    445 #[cfg(not(target_arch = "wasm32"))]
    446 #[test]
    447 fn native_scope_and_owned_futures_retain_thread_guarantees() {
    448     fn send_sync<T: Send + Sync>() {}
    449     fn send<T: Send>(_: T) {}
    450     send_sync::<SignerHandle>();
    451     send_sync::<SignerSession>();
    452     let Fixture { session, .. } = scope();
    453     send(session.observe());
    454     send(session.close());
    455 }
    456 
    457 #[cfg(target_arch = "wasm32")]
    458 #[test]
    459 fn browser_scope_accepts_rc_local_provider_and_callbacks() {
    460     let control = control();
    461     let session = SignerSession::new(SignerHandle::new(
    462         Shared::new(Provider(control.clone())),
    463         Shared::new(Callbacks(control)),
    464     ));
    465     assert_eq!(block_on(session.observe()).unwrap().identity(), key(false));
    466     assert!(matches!(
    467         block_on(session.sign_exact(exact_intent(false, 1))).kind(),
    468         radroots_signing::issuance::OutcomeKind::NotDispatched(
    469             ProviderError::CapabilityUnavailable
    470         )
    471     ));
    472     block_on(session.close()).unwrap();
    473     assert_eq!(session.state(), SessionState::Closed);
    474 }
    475 
    476 #[cfg(all(target_arch = "wasm32", feature = "client_session"))]
    477 #[test]
    478 fn browser_client_composes_local_host_and_retained_callback_scope() {
    479     use radroots_execution::session::{ClientSession, HostFuture, SessionHost};
    480     struct LocalHost(std::rc::Rc<std::cell::Cell<u8>>);
    481     impl LocalHost {
    482         fn run(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    483             Box::pin(async move {
    484                 self.0.set(self.0.get() + 1);
    485                 Ok(())
    486             })
    487         }
    488     }
    489     impl SessionHost for LocalHost {
    490         fn start(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    491             self.run()
    492         }
    493         fn quiesce(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    494             self.run()
    495         }
    496         fn disconnect(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    497             self.run()
    498         }
    499         fn dispose_callbacks(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    500             self.run()
    501         }
    502         fn close_storage(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    503             self.run()
    504         }
    505     }
    506     let observations = std::rc::Rc::new(std::cell::Cell::new(0));
    507     let client = ClientSession::new(LocalHost(observations.clone()), core::num::NonZeroU16::MIN);
    508     let control = control();
    509     block_on(client.attach_signer(SignerHandle::new(
    510         Shared::new(Provider(control.clone())),
    511         Shared::new(Callbacks(control)),
    512     )))
    513     .unwrap();
    514     assert_eq!(observations.get(), 0);
    515     block_on(client.start()).unwrap();
    516     block_on(client.close()).unwrap();
    517     assert_eq!(observations.get(), 5);
    518 }
    519 
    520 fn exact_intent(second: bool, operation: u8) -> radroots_signing::issuance::SigningIntent {
    521     use radroots_signing::issuance::{ArtifactRole, SigningIntent};
    522     let plan = radroots_event_codec::authoring::AuthoredEventPlan::from_generic(
    523         radroots_event::GenericEventDraft::new(
    524             "radroots.social.geochat.v1",
    525             20_000,
    526             1_700_000_000,
    527             vec![],
    528             "synthetic captured scope",
    529             key(second).to_hex(),
    530         )
    531         .unwrap(),
    532     )
    533     .unwrap();
    534     SigningIntent::new(
    535         radroots_domain::OperationId::from_bytes([operation; 32]),
    536         [9; 32],
    537         plan,
    538         ArtifactRole::PublicEvent,
    539         None,
    540         ProviderCall::new(
    541             key(second),
    542             core::num::NonZeroU64::new(1_700_000_010_000).unwrap(),
    543             radroots_signing::request::CancellationSignal::new(),
    544         ),
    545     )
    546     .unwrap()
    547 }
    548 
    549 #[cfg(not(target_arch = "wasm32"))]
    550 #[test]
    551 fn exact_issuance_requires_successful_observation_actual_support_and_the_frozen_key() {
    552     use radroots_signing::issuance::ExactIssuer;
    553     use radroots_signing::issuance::OutcomeKind;
    554     let Fixture {
    555         session, control, ..
    556     } = scope();
    557     assert!(matches!(
    558         block_on(ExactIssuer::issue_exact(&session, exact_intent(false, 1))).kind(),
    559         OutcomeKind::NotDispatched(ProviderError::CapabilityUnavailable)
    560     ));
    561     block_on(session.observe()).unwrap();
    562     assert!(matches!(
    563         block_on(session.sign_exact(exact_intent(false, 1))).kind(),
    564         OutcomeKind::NotDispatched(ProviderError::CapabilityUnavailable)
    565     ));
    566     assert_eq!(control.sign_calls.load(Ordering::SeqCst), 0);
    567     *control.current.lock().unwrap() =
    568         state(false, false).with_exact_issuance(Some(ReplayCapability::NonReplayable));
    569     block_on(session.observe()).unwrap();
    570     assert!(matches!(
    571         block_on(session.sign_exact(exact_intent(true, 1))).kind(),
    572         OutcomeKind::NotDispatched(ProviderError::IdentityChanged)
    573     ));
    574     assert!(!session.identity_changed());
    575     assert!(matches!(
    576         block_on(ExactIssuer::issue_exact(&session, exact_intent(false, 1))).kind(),
    577         OutcomeKind::Unknown(_)
    578     ));
    579     assert_eq!(control.sign_calls.load(Ordering::SeqCst), 1);
    580     *control.current.lock().unwrap() =
    581         state(true, false).with_exact_issuance(Some(ReplayCapability::NonReplayable));
    582     assert_eq!(
    583         block_on(session.observe()),
    584         Err(ProviderError::IdentityChanged)
    585     );
    586     assert!(matches!(
    587         block_on(session.sign_exact(exact_intent(false, 1))).kind(),
    588         OutcomeKind::NotDispatched(ProviderError::IdentityChanged)
    589     ));
    590     assert_eq!(control.sign_calls.load(Ordering::SeqCst), 1);
    591     block_on(session.close()).unwrap();
    592 
    593     let Fixture {
    594         session, control, ..
    595     } = scope();
    596     let (send, receive) = oneshot::channel();
    597     drop(send);
    598     *control.response.lock().unwrap() = Some(receive);
    599     assert!(block_on(session.observe()).is_err());
    600     assert!(matches!(
    601         block_on(session.sign_exact(exact_intent(false, 1))).kind(),
    602         OutcomeKind::NotDispatched(ProviderError::CapabilityUnavailable)
    603     ));
    604     assert_eq!(control.sign_calls.load(Ordering::SeqCst), 0);
    605     block_on(session.close()).unwrap();
    606 }
    607 
    608 #[cfg(not(target_arch = "wasm32"))]
    609 #[test]
    610 fn pending_exact_issuance_retains_callbacks_until_its_bound_outcome_is_observed() {
    611     use radroots_signing::issuance::ExactIssuer;
    612     use radroots_signing::issuance::{OutcomeKind, SigningOutcome};
    613     let Fixture {
    614         session,
    615         control,
    616         provider,
    617         callbacks,
    618     } = scope();
    619     *control.current.lock().unwrap() =
    620         state(false, false).with_exact_issuance(Some(ReplayCapability::NonReplayable));
    621     block_on(session.observe()).unwrap();
    622     let input = exact_intent(false, 1);
    623     let binding = input.binding();
    624     let (send, receive) = oneshot::channel();
    625     *control.sign_response.lock().unwrap() = Some(receive);
    626     let mut issue = ExactIssuer::issue_exact(&session, input);
    627     let mut cx = Context::from_waker(noop_waker_ref());
    628     assert!(issue.as_mut().poll(&mut cx).is_pending());
    629     let mut close = Box::pin(session.close());
    630     assert!(close.as_mut().poll(&mut cx).is_pending());
    631     assert_eq!(session.state(), SessionState::Closing);
    632     assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0);
    633     assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some());
    634     send.send(SigningOutcome::unknown(
    635         binding,
    636         ProviderError::ProviderFailure,
    637     ))
    638     .unwrap();
    639     let Poll::Ready(outcome) = issue.as_mut().poll(&mut cx) else {
    640         panic!("outcome not received");
    641     };
    642     assert_eq!(outcome.binding(), binding);
    643     assert!(matches!(outcome.kind(), OutcomeKind::Unknown(_)));
    644     assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(()))));
    645     assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none());
    646 }
    647 
    648 #[cfg(not(target_arch = "wasm32"))]
    649 #[test]
    650 fn exact_callback_binding_cannot_claim_another_operations_result() {
    651     use radroots_signing::issuance::{OutcomeKind, RejectionReason};
    652     let Fixture {
    653         session, control, ..
    654     } = scope();
    655     *control.current.lock().unwrap() =
    656         state(false, false).with_exact_issuance(Some(ReplayCapability::NonReplayable));
    657     block_on(session.observe()).unwrap();
    658     *control.sign_binding.lock().unwrap() = Some(exact_intent(false, 2).binding());
    659     let input = exact_intent(false, 1);
    660     let expected = input.binding();
    661     let outcome = block_on(session.sign_exact(input));
    662     assert_eq!(outcome.binding(), expected);
    663     let OutcomeKind::Rejected(rejected) = outcome.kind() else {
    664         panic!("wrong binding promoted");
    665     };
    666     assert_eq!(rejected.reason(), RejectionReason::BindingMismatch);
    667     assert!(rejected.fingerprint().is_none());
    668     block_on(session.close()).unwrap();
    669 }
    670 
    671 fn crypto_call(second: bool) -> ProviderCall {
    672     ProviderCall::new(
    673         key(second),
    674         core::num::NonZeroU64::new(1_700_000_010_000).unwrap(),
    675         radroots_signing::request::CancellationSignal::new(),
    676     )
    677 }
    678 
    679 #[cfg(not(target_arch = "wasm32"))]
    680 #[test]
    681 fn private_crypto_reobserves_the_attached_identity_and_capability_without_fallback() {
    682     let Fixture {
    683         session, control, ..
    684     } = scope();
    685     assert_eq!(
    686         block_on(session.encrypt_private(
    687             crypto_call(false),
    688             key(true),
    689             PrivateText::new("private model").unwrap()
    690         ))
    691         .unwrap_err(),
    692         ProviderError::CapabilityUnavailable
    693     );
    694     assert_eq!(control.calls.load(Ordering::SeqCst), 0);
    695     block_on(session.observe()).unwrap();
    696     assert_eq!(
    697         block_on(session.encrypt_private(
    698             crypto_call(false),
    699             key(true),
    700             PrivateText::new("private model").unwrap()
    701         ))
    702         .unwrap_err(),
    703         ProviderError::CapabilityUnavailable
    704     );
    705     assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 0);
    706     *control.current.lock().unwrap() = state(false, true);
    707     assert_eq!(
    708         block_on(session.encrypt_private(
    709             crypto_call(true),
    710             key(true),
    711             PrivateText::new("private model").unwrap()
    712         ))
    713         .unwrap_err(),
    714         ProviderError::IdentityChanged
    715     );
    716     assert!(!session.identity_changed());
    717     assert_eq!(
    718         block_on(session.encrypt_private(
    719             crypto_call(false),
    720             key(true),
    721             PrivateText::new("private model").unwrap()
    722         ))
    723         .unwrap_err(),
    724         ProviderError::ProviderFailure
    725     );
    726     // This is structural port data, not authenticated NIP-44 ciphertext.
    727     assert_eq!(
    728         block_on(session.decrypt_private(
    729             crypto_call(false),
    730             key(true),
    731             PrivateCiphertext::parse(&"A".repeat(132)).unwrap()
    732         ))
    733         .unwrap_err(),
    734         ProviderError::ProviderFailure
    735     );
    736     assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 2);
    737     *control.current.lock().unwrap() = state(true, true);
    738     assert_eq!(
    739         block_on(session.encrypt_private(
    740             crypto_call(false),
    741             key(true),
    742             PrivateText::new("private model").unwrap()
    743         ))
    744         .unwrap_err(),
    745         ProviderError::IdentityChanged
    746     );
    747     *control.current.lock().unwrap() = state(false, true);
    748     assert_eq!(
    749         block_on(session.decrypt_private(
    750             crypto_call(false),
    751             key(true),
    752             PrivateCiphertext::parse(&"A".repeat(132)).unwrap()
    753         ))
    754         .unwrap_err(),
    755         ProviderError::IdentityChanged
    756     );
    757     assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 2);
    758     block_on(session.close()).unwrap();
    759     assert_eq!(
    760         block_on(session.encrypt_private(
    761             crypto_call(false),
    762             key(true),
    763             PrivateText::new("private model").unwrap()
    764         ))
    765         .unwrap_err(),
    766         ProviderError::CapabilityUnavailable
    767     );
    768 }
    769 
    770 #[cfg(not(target_arch = "wasm32"))]
    771 #[test]
    772 fn scoped_private_crypto_retains_callbacks_until_the_issued_call_finishes() {
    773     let Fixture {
    774         session,
    775         control,
    776         provider,
    777         callbacks,
    778     } = scope();
    779     *control.current.lock().unwrap() = state(false, true);
    780     block_on(session.observe()).unwrap();
    781     let (send, receive) = oneshot::channel();
    782     *control.crypto_response.lock().unwrap() = Some(receive);
    783     let mut encrypt = Box::pin(session.encrypt_private(
    784         crypto_call(false),
    785         key(true),
    786         PrivateText::new("private model").unwrap(),
    787     ));
    788     let mut cx = Context::from_waker(noop_waker_ref());
    789     assert!(encrypt.as_mut().poll(&mut cx).is_pending());
    790     let mut close = Box::pin(session.close());
    791     assert!(close.as_mut().poll(&mut cx).is_pending());
    792     assert_eq!(session.state(), SessionState::Closing);
    793     assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0);
    794     assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some());
    795     send.send(()).unwrap();
    796     assert!(matches!(
    797         encrypt.as_mut().poll(&mut cx),
    798         Poll::Ready(Err(ProviderError::ProviderFailure))
    799     ));
    800     assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(()))));
    801     assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none());
    802 }