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 }