commands.rs (7872B)
1 use core::num::NonZeroU64; 2 use radroots_domain::{PublicKey, UnixSeconds}; 3 use radroots_execution::session::{ 4 HostFuture, 5 command::{CommandIo, capture_dm_route, selected_dm_targets}, 6 }; 7 use radroots_nostr::signing::gift_wrap::{randomized_past_time, wrap_retained_seal}; 8 use radroots_protocol::nip59::CapturedDmRoute; 9 use radroots_signing::provider::{NonceSource, ProviderError}; 10 use radroots_storage::command::{OperationError, PrivateEnvelopeCandidate}; 11 use radroots_transport::{ 12 EventSink, EventSource, TargetSet, 13 policy::{SatisfactionClass, SatisfactionPolicy}, 14 source::{FetchBounds, FetchRequest, FetchSelector}, 15 }; 16 use radroots_transport_nostr::{Config, NostrTransport}; 17 use radroots_transport_nostr_browser::BrowserConnector; 18 use std::{ 19 sync::Arc, 20 sync::atomic::{AtomicU8, Ordering}, 21 }; 22 use wasm_bindgen::JsCast; 23 24 pub(crate) struct BrowserCommands { 25 transport: NostrTransport, 26 connector: Arc<BrowserConnector>, 27 read: TargetSet, 28 write: TargetSet, 29 policy: SatisfactionPolicy, 30 mode: AtomicU8, 31 } 32 impl BrowserCommands { 33 pub(crate) fn new(config: Config, policy: SatisfactionPolicy) -> Result<Self, OperationError> { 34 let read = TargetSet::new( 35 config 36 .read_relays() 37 .map(|relay| relay.to_target()) 38 .collect::<Result<_, _>>() 39 .map_err(|_| OperationError::InvalidCommand)?, 40 ) 41 .map_err(|_| OperationError::InvalidCommand)?; 42 let write = TargetSet::new( 43 config 44 .write_relays() 45 .map(|relay| relay.to_target()) 46 .collect::<Result<_, _>>() 47 .map_err(|_| OperationError::InvalidCommand)?, 48 ) 49 .map_err(|_| OperationError::InvalidCommand)?; 50 if policy.class() != SatisfactionClass::Accepted { 51 return Err(OperationError::InvalidCommand); 52 } 53 policy 54 .validate_for(&write) 55 .map_err(|_| OperationError::InvalidCommand)?; 56 let connector = Arc::new(BrowserConnector::default()); 57 Ok(Self { 58 transport: NostrTransport::new(config, connector.clone()), 59 connector, 60 read, 61 write, 62 policy, 63 mode: AtomicU8::new(0), 64 }) 65 } 66 pub(crate) fn select(&self, online: bool) -> Result<(), OperationError> { 67 let mode = if online { 2 } else { 1 }; 68 match self 69 .mode 70 .compare_exchange(0, mode, Ordering::AcqRel, Ordering::Acquire) 71 { 72 Ok(_) => Ok(()), 73 Err(current) if current == mode => Ok(()), 74 Err(_) => Err(OperationError::Unauthorized), 75 } 76 } 77 pub(crate) async fn disconnect(&self) { 78 self.transport.shutdown().await; 79 } 80 pub(crate) async fn dispose(&self) -> Result<(), OperationError> { 81 self.connector 82 .close() 83 .await 84 .map_err(|_| OperationError::RecoveryRequired) 85 } 86 fn capture_route<'a>( 87 &self, 88 recipient: PublicKey, 89 raw_sources: impl IntoIterator<Item = &'a str>, 90 ) -> Result<CapturedDmRoute, OperationError> { 91 capture_dm_route(recipient, raw_sources, &self.write) 92 } 93 } 94 impl CommandIo for BrowserCommands { 95 fn enabled(&self) -> bool { 96 self.mode.load(Ordering::Acquire) == 2 97 } 98 fn now(&self) -> Result<UnixSeconds, OperationError> { 99 unix_seconds() 100 } 101 fn public_targets(&self) -> Result<TargetSet, OperationError> { 102 if !self.enabled() { 103 return Err(OperationError::Unauthorized); 104 } 105 Ok(self.write.clone()) 106 } 107 fn seal_time(&self, now: UnixSeconds) -> Result<UnixSeconds, OperationError> { 108 let time = randomized_past_time( 109 NonZeroU64::new(now.get()).ok_or(OperationError::RecoveryRequired)?, 110 &BrowserNonceSource, 111 ) 112 .map_err(|_| OperationError::RecoveryRequired)?; 113 UnixSeconds::new(time.get()).map_err(|_| OperationError::RecoveryRequired) 114 } 115 fn route( 116 &self, 117 recipient: PublicKey, 118 deadline: NonZeroU64, 119 ) -> HostFuture<'_, Result<CapturedDmRoute, OperationError>> { 120 Box::pin(async move { 121 if !self.enabled() { 122 return Err(OperationError::Unauthorized); 123 } 124 let selector = FetchSelector::all() 125 .with_kinds(vec![10050]) 126 .and_then(|selector| selector.with_authors(vec![recipient])) 127 .map_err(|_| OperationError::InvalidCommand)?; 128 let bounds = 129 FetchBounds::new(2, deadline.get()).map_err(|_| OperationError::InvalidCommand)?; 130 let request = FetchRequest::new(self.delivery_id()?, self.read.clone(), bounds) 131 .map_err(|_| OperationError::InvalidCommand)? 132 .with_selector(selector); 133 let page = self 134 .transport 135 .fetch(request) 136 .await 137 .map_err(|_| OperationError::MissingHistory)?; 138 self.capture_route( 139 recipient, 140 page.events() 141 .iter() 142 .map(|observed| observed.event().raw_json()), 143 ) 144 }) 145 } 146 fn targets(&self, route: &CapturedDmRoute) -> Result<TargetSet, OperationError> { 147 selected_dm_targets(route, &self.write) 148 } 149 fn publication_policy(&self) -> SatisfactionPolicy { 150 self.policy.clone() 151 } 152 fn private_envelope( 153 &self, 154 recipient: PublicKey, 155 raw_seal: &str, 156 ) -> Result<PrivateEnvelopeCandidate, OperationError> { 157 let now = NonZeroU64::new(self.now()?.get()).ok_or(OperationError::RecoveryRequired)?; 158 let wrapped = wrap_retained_seal(raw_seal, recipient, now, &BrowserNonceSource) 159 .map_err(|_| OperationError::InvalidEvidence)?; 160 wrapped.with_wrapping_key(|key| { 161 PrivateEnvelopeCandidate::from_obtained(recipient, wrapped.signed_json(), key) 162 }) 163 } 164 fn delivery_id(&self) -> Result<String, OperationError> { 165 let bytes = BrowserNonceSource 166 .next_nonce() 167 .map_err(|_| OperationError::RecoveryRequired)?; 168 let mut output = String::with_capacity(64); 169 const HEX: &[u8; 16] = b"0123456789abcdef"; 170 for byte in bytes { 171 output.push(HEX[usize::from(byte >> 4)] as char); 172 output.push(HEX[usize::from(byte & 15)] as char); 173 } 174 Ok(output) 175 } 176 fn publish( 177 &self, 178 request: radroots_transport::sink::DeliveryRequest, 179 selected: TargetSet, 180 ) -> HostFuture<'_, Result<radroots_transport::DeliveryReceipt, radroots_transport::SinkFailure>> 181 { 182 self.transport.deliver_selected(request, selected) 183 } 184 } 185 186 pub(crate) fn unix_seconds() -> Result<UnixSeconds, OperationError> { 187 let millis = js_sys::Date::now(); 188 if !millis.is_finite() || millis < 1000.0 { 189 return Err(OperationError::RecoveryRequired); 190 } 191 UnixSeconds::new((millis / 1000.0) as u64).map_err(|_| OperationError::RecoveryRequired) 192 } 193 194 /// Explicit origin-thread WebCrypto CSPRNG. Construction is inert; failed 195 /// entropy acquisition never returns a partial nonce or falls back to a clock. 196 pub struct BrowserNonceSource; 197 impl NonceSource for BrowserNonceSource { 198 fn next_nonce(&self) -> Result<[u8; 32], ProviderError> { 199 let crypto = js_sys::Reflect::get(&js_sys::global(), &"crypto".into()) 200 .map_err(|_| ProviderError::CapabilityUnavailable)? 201 .dyn_into::<web_sys::Crypto>() 202 .map_err(|_| ProviderError::CapabilityUnavailable)?; 203 let mut nonce = [0; 32]; 204 crypto 205 .get_random_values_with_u8_array(&mut nonce) 206 .map_err(|_| ProviderError::CapabilityUnavailable)?; 207 Ok(nonce) 208 } 209 }