lib

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

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 }