lib

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

signer.rs (4442B)


      1 use radroots_nostr::{
      2     key::parse_secret_key,
      3     signing::{LocalSigner, OsNonceSource},
      4 };
      5 use radroots_signing::{
      6     Signer,
      7     issuance::{SigningIntent, SigningOutcome},
      8     provider::{
      9         ParticipantProvider, PrivateCiphertext, PrivateText, ProviderCall, ProviderError,
     10         ProviderState,
     11     },
     12     signer::BoxFuture,
     13 };
     14 use std::sync::{
     15     Arc,
     16     atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
     17 };
     18 use tokio::sync::Notify;
     19 
     20 pub(crate) struct MeasuredSigner {
     21     local: LocalSigner,
     22     pub calls: AtomicU64,
     23     pub legacy_calls: AtomicU64,
     24     pub unknown: AtomicBool,
     25     pub rejection: AtomicUsize,
     26     pub pause_next: AtomicBool,
     27     pub paused: AtomicBool,
     28     release: Notify,
     29 }
     30 impl MeasuredSigner {
     31     pub fn new(unknown: bool, pause: bool) -> Arc<Self> {
     32         Arc::new(Self {
     33             local: LocalSigner::new(
     34                 parse_secret_key(
     35                     "0000000000000000000000000000000000000000000000000000000000000001",
     36                 )
     37                 .expect("synthetic scalar"),
     38             )
     39             .expect("synthetic signer")
     40             .with_nonce_source(Arc::new(OsNonceSource)),
     41             calls: AtomicU64::new(0),
     42             legacy_calls: AtomicU64::new(0),
     43             unknown: AtomicBool::new(unknown),
     44             rejection: AtomicUsize::new(0),
     45             pause_next: AtomicBool::new(pause),
     46             paused: AtomicBool::new(false),
     47             release: Notify::new(),
     48         })
     49     }
     50     pub fn release(&self) {
     51         self.release.notify_one();
     52     }
     53 }
     54 impl Signer for MeasuredSigner {
     55     fn status(
     56         &self,
     57     ) -> BoxFuture<'_, Result<radroots_signing::SignerStatus, radroots_signing::Error>> {
     58         self.local.status()
     59     }
     60     fn sign(
     61         &self,
     62         request: radroots_signing::SignRequest,
     63     ) -> BoxFuture<'_, Result<radroots_signing::SignReceipt, radroots_signing::Error>> {
     64         self.legacy_calls.fetch_add(1, Ordering::SeqCst);
     65         self.local.sign(request)
     66     }
     67 }
     68 impl ParticipantProvider for MeasuredSigner {
     69     fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> {
     70         self.local.provider_state()
     71     }
     72     fn sign_exact(&self, intent: SigningIntent) -> BoxFuture<'_, SigningOutcome> {
     73         Box::pin(async move {
     74             self.calls.fetch_add(1, Ordering::SeqCst);
     75             match self.rejection.load(Ordering::SeqCst) {
     76                 1 => {
     77                     return SigningOutcome::capture(
     78                         &intent,
     79                         "synthetic private rejection canary".into(),
     80                         None,
     81                     );
     82                 }
     83                 2 => return SigningOutcome::capture(&intent, "X".repeat(65537), None),
     84                 3 => {
     85                     let foreign = radroots_signing::issuance::IntentBinding::from_components(
     86                         radroots_domain::OperationId::from_bytes([0xf1; 32]),
     87                         [0xf2; 32],
     88                         [0xf3; 32],
     89                         radroots_signing::issuance::ArtifactRole::PublicEvent,
     90                         None,
     91                         std::num::NonZeroU64::new(1).unwrap(),
     92                     )
     93                     .unwrap();
     94                     return SigningOutcome::not_dispatched(foreign, ProviderError::Cancelled);
     95                 }
     96                 _ => {}
     97             }
     98             if self.unknown.load(Ordering::SeqCst) {
     99                 return SigningOutcome::unknown(intent.binding(), ProviderError::ProviderFailure);
    100             }
    101             let outcome = self.local.sign_exact(intent).await;
    102             if self.pause_next.swap(false, Ordering::SeqCst) {
    103                 self.paused.store(true, Ordering::SeqCst);
    104                 self.release.notified().await;
    105                 self.paused.store(false, Ordering::SeqCst);
    106             }
    107             outcome
    108         })
    109     }
    110     fn encrypt_private(
    111         &self,
    112         call: ProviderCall,
    113         recipient: radroots_domain::PublicKey,
    114         plaintext: PrivateText,
    115     ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> {
    116         self.local.encrypt_private(call, recipient, plaintext)
    117     }
    118     fn decrypt_private(
    119         &self,
    120         call: ProviderCall,
    121         sender: radroots_domain::PublicKey,
    122         ciphertext: PrivateCiphertext,
    123     ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> {
    124         self.local.decrypt_private(call, sender, ciphertext)
    125     }
    126 }