nostr_double_ratchet/
lib.rs

1#[cfg(feature = "full")]
2pub mod app_keys;
3#[cfg(feature = "full")]
4pub mod device_link;
5#[cfg(feature = "full")]
6pub mod direct_message_subscriptions;
7pub mod error;
8#[cfg(feature = "full")]
9pub mod group;
10#[cfg(feature = "full")]
11pub mod group_manager;
12#[cfg(feature = "full")]
13pub mod group_wire;
14pub mod ids;
15pub mod invite;
16#[cfg(feature = "full")]
17pub mod message_builders;
18#[cfg(feature = "full")]
19pub mod message_origin;
20#[cfg(feature = "full")]
21pub mod multi_device;
22#[cfg(feature = "full")]
23pub mod one_to_many;
24pub mod protocol_types;
25#[cfg(feature = "full")]
26pub mod roster;
27#[cfg(feature = "full")]
28pub mod roster_editor;
29#[cfg(feature = "full")]
30pub mod sender_key;
31mod serde_hex;
32pub mod session;
33#[cfg(feature = "full")]
34pub mod session_manager;
35#[cfg(feature = "full")]
36pub mod shared_channel;
37pub mod utils;
38pub mod wire;
39
40#[cfg(feature = "full")]
41pub use app_keys::{
42    build_app_keys_device_authorization_filter,
43    encrypted_device_label_payloads_from_app_keys_event, is_app_keys_event,
44    resolve_app_keys_owner_for_device, AppKeys, DeviceEntry, DeviceLabels, DeviceMembership,
45    VerifiedAppKeysIndex, APP_KEYS_ENCRYPTED_DEVICE_LABELS_FACT,
46    APP_KEYS_ENCRYPTED_DEVICE_LABELS_SCHEMA, APP_KEYS_FACT_TYPE, APP_KEYS_OWNER_PUBKEY_FACT,
47    APP_KEYS_SCHEMA, APP_KEYS_SNAPSHOT_KIND,
48};
49#[cfg(feature = "full")]
50pub use device_link::{
51    deterministic_link_invite_for_device, deterministic_link_invite_for_device_link_request,
52    encode_compact_device_link_request, parse_compact_device_link_request, DeviceLinkRequest,
53};
54#[cfg(feature = "full")]
55pub use direct_message_subscriptions::{
56    app_keys_subscription_authors, build_app_keys_backfill_filter,
57    build_direct_message_backfill_filter, build_invite_backfill_filter,
58    build_invite_response_backfill_filter, build_protocol_discovery_filters,
59    build_runtime_backfill_filters, direct_message_subscription_authors,
60    invite_response_subscription_recipients, DirectMessageSubscriptionTracker,
61    RuntimeSubscriptionRegistration, RuntimeSubscriptionTracker,
62};
63pub use error::{DomainError, Error, Result};
64#[cfg(feature = "full")]
65pub use group::*;
66#[cfg(feature = "full")]
67pub use group_manager::*;
68#[cfg(feature = "full")]
69pub use group_wire::{
70    build_group_roster_fact_filter, group_roster_unsigned_event, is_group_roster_fact_event,
71    parse_group_roster_fact_event, project_group_roster_fact_events, GroupEventManager,
72    GroupRosterFact, JsonGroupPayloadCodecV1, GROUP_ROSTER_FACT_KIND, GROUP_ROSTER_FACT_SCHEMA,
73    GROUP_ROSTER_FACT_TYPE,
74};
75pub use ids::{DevicePubkey, OwnerPubkey, UnixSeconds};
76pub use invite::{Invite, InviteResponse, InviteResponseEnvelope, OwnerClaimVerifier};
77#[cfg(feature = "full")]
78pub use message_builders::*;
79#[cfg(feature = "full")]
80pub use message_origin::{classify_message_origin, MessageOrigin};
81#[cfg(feature = "full")]
82pub use multi_device::{
83    apply_app_keys_snapshot, apply_app_keys_snapshot_with_required_device,
84    evaluate_device_registration_state, resolve_conversation_candidate_pubkeys,
85    resolve_invite_owner_routing, resolve_rumor_peer_pubkey, select_latest_app_keys_from_events,
86    should_require_relay_registration_confirmation, AppKeysSnapshot, AppKeysSnapshotDecision,
87    DeviceRegistrationState, InviteOwnerRoutingResolution,
88};
89#[cfg(feature = "full")]
90pub use one_to_many::*;
91pub use protocol_types::{ProtocolContext, MAX_SKIP};
92#[cfg(feature = "full")]
93pub use roster::{AuthorizedDevice, DeviceRoster, RosterSnapshotDecision};
94#[cfg(feature = "full")]
95pub use roster_editor::RosterEditor;
96#[cfg(feature = "full")]
97pub use sender_key::*;
98pub use session::{
99    Header, MessageEnvelope, ReceiveOutcome, ReceivePlan, SendOutcome, SendPlan,
100    SerializableKeyPair, Session, SessionState, SkippedKeysEntry,
101};
102#[cfg(feature = "full")]
103pub use session_manager::{
104    Delivery, DeviceRecordSnapshot, PreparedSend, ProcessedInviteResponse, PruneReport,
105    ReceivedMessage, RelayGap, SessionManager, SessionManagerSnapshot, UserRecordSnapshot,
106};
107#[cfg(feature = "full")]
108pub use shared_channel::SharedChannel;
109#[cfg(feature = "full")]
110pub use wire::{
111    group_sender_key_message_event, parse_group_sender_key_message_event,
112    parse_group_sender_key_message_event_unchecked, parse_roster_event, roster_unsigned_event,
113    DecodedRosterEvent, GROUP_SENDER_KEY_MESSAGE_KIND, ROSTER_EVENT_KIND,
114};
115pub use wire::{
116    invite_response_event, invite_unsigned_event, invite_url, message_event, parse_invite_event,
117    parse_invite_response_event, parse_invite_url, parse_message_event, INVITE_EVENT_KIND,
118    INVITE_LIST_LABEL, INVITE_RESPONSE_KIND, MESSAGE_EVENT_KIND,
119};
120
121pub(crate) use ids::owner_pubkey_from_device_pubkey;
122pub(crate) use utils::{
123    device_pubkey_from_secret_bytes, kdf, random_secret_key_bytes, secret_key_from_bytes,
124};
125
126#[cfg(feature = "full")]
127impl OwnerClaimVerifier for AppKeys {
128    fn has_device(&self, _device_pubkey: DevicePubkey, device_identity: nostr::PublicKey) -> bool {
129        self.get_device(&device_identity).is_some()
130    }
131}
132
133#[cfg(feature = "full")]
134pub const APP_KEYS_EVENT_KIND: u32 = APP_KEYS_SNAPSHOT_KIND;
135pub const CHAT_MESSAGE_KIND: u32 = 14;
136pub const CHAT_SETTINGS_KIND: u32 = 10448;
137pub const REACTION_KIND: u32 = 7;
138pub const RECEIPT_KIND: u32 = 15;
139pub const TYPING_KIND: u32 = 25;
140pub const SHARED_CHANNEL_KIND: u32 = 4;
141pub const EXPIRATION_TAG: &str = "expiration";
142
143#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
144#[serde(rename_all = "camelCase")]
145pub struct SendOptions {
146    pub expires_at: Option<u64>,
147    pub ttl_seconds: Option<u64>,
148}
149
150#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
151#[serde(rename_all = "camelCase")]
152pub struct ChatSettingsPayloadV1 {
153    #[serde(rename = "type")]
154    pub typ: String,
155    pub v: u32,
156    #[serde(skip_serializing_if = "Option::is_none")]
157    pub message_ttl_seconds: Option<u64>,
158}
159
160pub fn process_invite_response_event(
161    invite: &Invite,
162    event: &nostr::Event,
163    inviter_private_key: [u8; 32],
164) -> Result<Option<InviteResponse>> {
165    let envelope = parse_invite_response_event(event)
166        .map_err(|error| Error::InvalidEvent(error.to_string()))?;
167    let mut rng = rand::rngs::OsRng;
168    let mut ctx = ProtocolContext::new(UnixSeconds(event.created_at.as_secs()), &mut rng);
169    let mut invite = invite.clone();
170    invite
171        .process_response(&mut ctx, &envelope, inviter_private_key)
172        .map(Some)
173}
174
175pub trait SessionNostrExt {
176    fn send_event(&mut self, event: nostr::UnsignedEvent) -> Result<nostr::Event>;
177    fn receive(&mut self, event: &nostr::Event) -> Result<Option<String>>;
178}
179
180#[derive(serde::Deserialize)]
181#[serde(deny_unknown_fields)]
182struct StrictUnsignedRumor {
183    id: nostr::EventId,
184    pubkey: nostr::PublicKey,
185    created_at: nostr::Timestamp,
186    kind: nostr::Kind,
187    tags: nostr::Tags,
188    content: String,
189}
190
191fn validate_unsigned_rumor(payload: &[u8]) -> Result<()> {
192    let rumor: StrictUnsignedRumor = serde_json::from_slice(payload)?;
193    nostr::UnsignedEvent {
194        id: Some(rumor.id),
195        pubkey: rumor.pubkey,
196        created_at: rumor.created_at,
197        kind: rumor.kind,
198        tags: rumor.tags,
199        content: rumor.content,
200    }
201    .verify_id()?;
202    Ok(())
203}
204
205impl SessionNostrExt for Session {
206    fn send_event(&mut self, mut event: nostr::UnsignedEvent) -> Result<nostr::Event> {
207        event.ensure_id();
208        let payload = serde_json::to_vec(&event)?;
209        let now = UnixSeconds(
210            std::time::SystemTime::now()
211                .duration_since(std::time::UNIX_EPOCH)
212                .unwrap()
213                .as_secs(),
214        );
215        let plan = self.plan_send(&payload, now)?;
216        let envelope = self.apply_send(plan).envelope;
217        message_event(&envelope).map_err(|error| Error::InvalidEvent(error.to_string()))
218    }
219
220    fn receive(&mut self, event: &nostr::Event) -> Result<Option<String>> {
221        let envelope =
222            parse_message_event(event).map_err(|error| Error::InvalidEvent(error.to_string()))?;
223        if !self.matches_sender(envelope.sender) {
224            return Ok(None);
225        }
226        let mut rng = rand::rngs::OsRng;
227        let mut ctx = ProtocolContext::new(UnixSeconds(event.created_at.as_secs()), &mut rng);
228        let plan = self.plan_receive(&mut ctx, &envelope)?;
229        validate_unsigned_rumor(&plan.payload)?;
230        let outcome = self.apply_receive(plan);
231        let plaintext = String::from_utf8(outcome.payload)
232            .map_err(|error| Error::Decryption(error.to_string()))?;
233        Ok(Some(plaintext))
234    }
235}
236
237pub trait InviteNostrExt {
238    fn get_url(&self, root: &str) -> Result<String>;
239    fn get_event(&self) -> Result<nostr::UnsignedEvent>;
240    fn from_url(url: &str) -> Result<Invite>;
241    fn from_event(event: &nostr::Event) -> Result<Invite>;
242    fn process_invite_response(
243        &self,
244        event: &nostr::Event,
245        inviter_private_key: [u8; 32],
246    ) -> Result<Option<InviteResponse>>;
247}
248
249impl InviteNostrExt for Invite {
250    fn get_url(&self, root: &str) -> Result<String> {
251        invite_url(self, root).map_err(|error| Error::InvalidEvent(error.to_string()))
252    }
253
254    fn get_event(&self) -> Result<nostr::UnsignedEvent> {
255        if self.device_id.is_none() {
256            return Err(Error::DeviceIdRequired);
257        }
258        invite_unsigned_event(self).map_err(|error| Error::InvalidEvent(error.to_string()))
259    }
260
261    fn from_url(url: &str) -> Result<Invite> {
262        parse_invite_url(url).map_err(|error| Error::InvalidEvent(error.to_string()))
263    }
264
265    fn from_event(event: &nostr::Event) -> Result<Invite> {
266        parse_invite_event(event).map_err(|error| Error::InvalidEvent(error.to_string()))
267    }
268
269    fn process_invite_response(
270        &self,
271        event: &nostr::Event,
272        inviter_private_key: [u8; 32],
273    ) -> Result<Option<InviteResponse>> {
274        process_invite_response_event(self, event, inviter_private_key)
275    }
276}
277
278#[cfg(test)]
279mod architecture_tests {
280    #[test]
281    fn core_modules_do_not_manage_runtime_or_wire() {
282        let sources = [
283            include_str!("group.rs"),
284            include_str!("group_manager.rs"),
285            include_str!("invite.rs"),
286            include_str!("roster.rs"),
287            include_str!("roster_editor.rs"),
288            include_str!("sender_key.rs"),
289            include_str!("session.rs"),
290            include_str!("session_manager.rs"),
291        ];
292        for banned in [
293            "NdrRuntime",
294            "SessionManagerEvent",
295            "StorageAdapter",
296            "crossbeam",
297            "tokio",
298            "EventBuilder",
299            "Filter",
300            "crate::wire",
301            "wire::",
302            "pairwise_codec",
303            "GroupWireEnvelopeV1",
304            "GroupPairwisePayloadV1",
305            "GroupSenderKeyPlaintextV1",
306            "wire_format_version",
307        ] {
308            for source in sources {
309                assert!(
310                    !source.contains(banned),
311                    "core should stay deterministic and wire/runtime-free; found `{banned}`"
312                );
313            }
314        }
315    }
316}
nostr_double_ratchet/lib.rs

nostr_double_ratchet/
lib.rs
