lib

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

delivery.rs (11407B)


      1 //! Actual protected D ports using independently signed synthetic carriers.
      2 use super::{WorkspaceFixture, copied, plans::BrowserRng};
      3 use core::num::NonZeroU64;
      4 use futures::FutureExt;
      5 use nostr::{JsonUtil, nips::nip44};
      6 use radroots_domain::{OperationId, PublicKey};
      7 use radroots_storage::command::{
      8     ClaimAttemptRequest, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest,
      9     DeliveryIntent, EnvelopeCandidate,
     10 };
     11 use radroots_transport::{
     12     Target, TargetSet,
     13     policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy},
     14     sink::DeliveryRequestId,
     15 };
     16 use serde_json::{Value, json};
     17 use wasm_bindgen::prelude::*;
     18 
     19 #[wasm_bindgen]
     20 pub struct ObtainedEnvelope {
     21     candidate: EnvelopeCandidate,
     22 }
     23 #[wasm_bindgen]
     24 impl ObtainedEnvelope {
     25     pub fn event(&self) -> String {
     26         self.candidate.event_id().to_string()
     27     }
     28     pub fn raw(&self) -> String {
     29         self.candidate.raw_json().into()
     30     }
     31 }
     32 fn summary(report: &DeliveryAttempt) -> Value {
     33     json!({"request":report.intent().request_id().as_str(),"event":report.intent().event_id().to_string(),"transaction":report.transaction_id().to_string(),"at":report.retained_at().get(),"raw":report.raw_json(),"digest":hex::encode(report.envelope_digest()),"policy":hex::encode(report.intent().publication_policy_digest()),"targets":report.intent().targets().targets().iter().map(|target|target.uri().as_str()).collect::<Vec<_>>(),"selection":report.intent().selected_targets().map(|target|target.uri().as_str()).collect::<Vec<_>>(),"ordinals":report.target_ordinals()})
     34 }
     35 fn outcome(value: DeliveryAttemptOutcome) -> Value {
     36     match value {
     37         DeliveryAttemptOutcome::Claimed(report) => {
     38             json!({"kind":"claimed","report":summary(&report)})
     39         }
     40         DeliveryAttemptOutcome::Retained(report) => {
     41             json!({"kind":"retained","report":summary(&report)})
     42         }
     43         DeliveryAttemptOutcome::Unknown { operation, attempt } => {
     44             json!({"kind":"unknown","operation":operation.operation_id().to_string(),"command":operation.command_digest().to_string(),"transaction":operation.transaction_id().map(|tx|tx.to_string()),"request":attempt.as_str()})
     45         }
     46     }
     47 }
     48 impl WorkspaceFixture {
     49     async fn delivery_request(
     50         &self,
     51         n: u8,
     52         id: u8,
     53         selection: u16,
     54         mode: u8,
     55         envelope: &ObtainedEnvelope,
     56     ) -> Result<DeliveryAttemptRequest, JsValue> {
     57         let request = self.request(n, false).await?;
     58         let mut relays = super::plans::delivery_relays(mode & 15 == 6);
     59         if mode & 15 == 4 {
     60             relays[1] = "wss://unapproved.fixture.example/".into();
     61         }
     62         let targets = TargetSet::new(
     63             relays
     64                 .iter()
     65                 .map(|relay| Target::nostr_relay(relay).unwrap())
     66                 .collect(),
     67         )
     68         .unwrap();
     69         let policy = SatisfactionPolicy::new(
     70             SatisfactionClass::Accepted,
     71             if mode & 15 == 5 {
     72                 TargetPolicy::any()
     73             } else {
     74                 TargetPolicy::all()
     75             },
     76         );
     77         let selected = TargetSet::new(
     78             targets
     79                 .targets()
     80                 .iter()
     81                 .enumerate()
     82                 .filter(|(index, _)| selection & (1 << index) != 0)
     83                 .map(|(_, target)| target.clone())
     84                 .collect(),
     85         )
     86         .unwrap();
     87         let intent = DeliveryIntent::new(
     88             &hex::encode([id; 32]),
     89             envelope.candidate.event_id(),
     90             &targets,
     91             &policy,
     92             NonZeroU64::new(1_800_000).unwrap(),
     93         )
     94         .unwrap()
     95         .with_selection(&selected)
     96         .unwrap();
     97         DeliveryAttemptRequest::new(request.binding().clone(), envelope.candidate.work(), intent)
     98             .map_err(|error| JsValue::from_str(error.code()))
     99     }
    100 }
    101 #[wasm_bindgen]
    102 impl WorkspaceFixture {
    103     pub fn alternate_envelope(
    104         &self,
    105         original: &ObtainedEnvelope,
    106     ) -> Result<ObtainedEnvelope, JsValue> {
    107         let event = nostr::Event::from_json(original.candidate.raw_json()).unwrap();
    108         let context = nostr::secp256k1::Secp256k1::new();
    109         let mut scalar = [0; 32];
    110         scalar[31] = 3;
    111         let keys =
    112             nostr::Keys::new_with_ctx(&context, nostr::SecretKey::from_slice(&scalar).unwrap());
    113         let alternate = nostr::UnsignedEvent {
    114             id: Some(event.id),
    115             pubkey: event.pubkey,
    116             created_at: event.created_at,
    117             kind: event.kind,
    118             tags: event.tags.clone(),
    119             content: event.content.clone(),
    120         }
    121         .sign_with_ctx(&context, &mut BrowserRng, &keys)
    122         .unwrap();
    123         alternate.verify_with_ctx(&context).unwrap();
    124         assert_eq!(alternate.id, event.id);
    125         assert_ne!(alternate.as_json(), event.as_json());
    126         Ok(ObtainedEnvelope {
    127             candidate: EnvelopeCandidate::from_obtained(
    128                 original.candidate.work(),
    129                 &alternate.as_json(),
    130                 &scalar,
    131             )
    132             .map_err(|e| JsValue::from_str(e.code()))?,
    133         })
    134     }
    135     pub async fn envelope(&self, n: u8, index: u8, mode: u8) -> Result<ObtainedEnvelope, JsValue> {
    136         let request = self.request(n, false).await?;
    137         let snapshot = self
    138             .journal()
    139             .operation_snapshot(
    140                 request.binding().clone(),
    141                 OperationId::from_bytes([n; 32]),
    142                 Some(request.command().digest()),
    143                 copied(&self.proof),
    144             )
    145             .await
    146             .map_err(|error| JsValue::from_str(error.code()))?
    147             .ok_or(JsValue::from_str("missing_operation"))?;
    148         let recipient = snapshot
    149             .bound_plan()
    150             .unwrap()
    151             .chat_plan()
    152             .unwrap()
    153             .seals()
    154             .get(index as usize)
    155             .ok_or(JsValue::from_str("invalid_recipient"))?
    156             .recipient();
    157         let work = snapshot
    158             .publications()
    159             .iter()
    160             .find(|work| work.recipient() == recipient)
    161             .copied()
    162             .ok_or(JsValue::from_str("missing_work"))?;
    163         let retained = self
    164             .journal()
    165             .obtained_evidence(
    166                 ClaimAttemptRequest::new(
    167                     request.binding().clone(),
    168                     OperationId::from_bytes([n; 32]),
    169                     request.command().digest(),
    170                     *snapshot.bound_plan().unwrap().plan().digest(),
    171                     recipient,
    172                 ),
    173                 copied(&self.proof),
    174             )
    175             .await
    176             .map_err(|error| JsValue::from_str(error.code()))?
    177             .ok_or(JsValue::from_str("missing_output"))?;
    178         let context = nostr::secp256k1::Secp256k1::new();
    179         let mut scalar = [0; 32];
    180         scalar[31] = if mode == 3 { 1 } else { 3 };
    181         let keys =
    182             nostr::Keys::new_with_ctx(&context, nostr::SecretKey::from_slice(&scalar).unwrap());
    183         let recipient = nostr::PublicKey::from_slice(recipient.as_bytes()).unwrap();
    184         let plain = if mode == 2 {
    185             "different original seal"
    186         } else {
    187             retained.evidence().raw_json()
    188         };
    189         let encrypted = nip44::encrypt_with_rng(
    190             &mut BrowserRng,
    191             keys.secret_key(),
    192             &recipient,
    193             plain,
    194             nip44::Version::V2,
    195         )
    196         .unwrap();
    197         let event = nostr::UnsignedEvent {
    198             id: None,
    199             pubkey: keys.public_key(),
    200             created_at: nostr::Timestamp::from_secs(900),
    201             kind: nostr::Kind::GiftWrap,
    202             tags: nostr::Tags::from_list(vec![nostr::Tag::public_key(recipient)]),
    203             content: encrypted,
    204         }
    205         .sign_with_ctx(&context, &mut BrowserRng, &keys)
    206         .unwrap();
    207         event.verify_with_ctx(&context).unwrap();
    208         if mode == 1 {
    209             scalar[31] = 4;
    210         }
    211         let candidate = EnvelopeCandidate::from_obtained(work, &event.as_json(), &scalar)
    212             .map_err(|error| JsValue::from_str(error.code()))?;
    213         Ok(ObtainedEnvelope { candidate })
    214     }
    215     pub async fn store_envelope(
    216         &self,
    217         n: u8,
    218         id: u8,
    219         selection: u16,
    220         mode: u8,
    221         envelope: &ObtainedEnvelope,
    222     ) -> Result<String, JsValue> {
    223         let request = self
    224             .delivery_request(n, id, selection, mode, envelope)
    225             .await?;
    226         self.clock.after.set(match mode & 15 {
    227             1 => Some(900),
    228             2 => Some(2000),
    229             3 => Some(1800),
    230             _ => None,
    231         });
    232         self.journal()
    233             .prepare_delivery_attempt(
    234                 request,
    235                 copied(&self.proof),
    236                 if mode & 16 != 0 {
    237                     None
    238                 } else {
    239                     Some(&envelope.candidate)
    240                 },
    241             )
    242             .await
    243             .map(|value| outcome(value).to_string())
    244             .map_err(|error| JsValue::from_str(error.code()))
    245     }
    246     pub async fn store_envelope_unknown(
    247         &self,
    248         n: u8,
    249         id: u8,
    250         selection: u16,
    251         envelope: &ObtainedEnvelope,
    252         hook: js_sys::Function,
    253     ) -> Result<String, JsValue> {
    254         let request = self.delivery_request(n, id, selection, 0, envelope).await?;
    255         hook.call0(&JsValue::NULL)?;
    256         self.journal()
    257             .prepare_delivery_attempt(request, copied(&self.proof), Some(&envelope.candidate))
    258             .await
    259             .map(|value| outcome(value).to_string())
    260             .map_err(|error| JsValue::from_str(error.code()))
    261     }
    262     pub async fn abandon_envelope(
    263         &self,
    264         n: u8,
    265         id: u8,
    266         selection: u16,
    267         envelope: &ObtainedEnvelope,
    268     ) -> Result<(), JsValue> {
    269         let request = self.delivery_request(n, id, selection, 0, envelope).await?;
    270         if self
    271             .journal()
    272             .prepare_delivery_attempt(request, copied(&self.proof), Some(&envelope.candidate))
    273             .now_or_never()
    274             .is_some()
    275         {
    276             return Err(JsValue::from_str("unexpected_immediate_delivery_retention"));
    277         }
    278         Ok(())
    279     }
    280     pub async fn query_envelope(&self, n: u8, index: u8, id: u8) -> Result<String, JsValue> {
    281         let request = self.request(n, false).await?;
    282         let mut recipients = vec![
    283             self.input.participant(),
    284             request.chat_command().unwrap().peer(),
    285         ];
    286         recipients.sort_unstable();
    287         recipients.dedup();
    288         let recipient: PublicKey = *recipients
    289             .get(index as usize)
    290             .ok_or(JsValue::from_str("invalid_recipient"))?;
    291         self.journal()
    292             .delivery_attempt(
    293                 request.binding().clone(),
    294                 OperationId::from_bytes([n; 32]),
    295                 request.command().digest(),
    296                 recipient.into(),
    297                 DeliveryRequestId::parse(hex::encode([id; 32])).unwrap(),
    298                 copied(&self.proof),
    299             )
    300             .await
    301             .map(|value| {
    302                 value
    303                     .as_ref()
    304                     .map(summary)
    305                     .unwrap_or(Value::Null)
    306                     .to_string()
    307             })
    308             .map_err(|error| JsValue::from_str(error.code()))
    309     }
    310 }