iris-chat 0.1.59

Iris Chat command line client and shared encrypted chat core
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use super::*;

impl AppCore {
    pub(super) fn publish_group_roster_fact(&mut self, group: &GroupSnapshot) -> bool {
        let Some(logged_in) = self.logged_in.as_ref() else {
            return false;
        };
        let Some(owner_keys) = logged_in.owner_keys.as_ref() else {
            return false;
        };
        let local_owner =
            nostr_double_ratchet::OwnerPubkey::from_bytes(logged_in.owner_pubkey.to_bytes());
        if !group.admins.contains(&local_owner) {
            return false;
        }
        let unsigned = match nostr_double_ratchet::group_roster_unsigned_event(
            logged_in.owner_pubkey,
            group,
        ) {
            Ok(unsigned) => unsigned,
            Err(error) => {
                self.push_debug_log("group.roster_fact.publish", error.to_string());
                return false;
            }
        };
        let event = match unsigned.sign_with_keys(owner_keys) {
            Ok(event) => event,
            Err(error) => {
                self.push_debug_log("group.roster_fact.publish", error.to_string());
                return false;
            }
        };
        if self.capture_authorization_event(&event).is_err() {
            return false;
        }
        // GroupManager distributes this metadata through the members' ratchets.
        // Keep the signed authorization record locally for device history sync.
        true
    }

    pub(super) fn publish_local_app_keys_snapshot_only(&mut self, label: &'static str) -> bool {
        let Some(logged_in) = self.logged_in.as_ref() else {
            return false;
        };
        if self.defer_owner_app_keys_publish {
            return false;
        }
        let Some(owner_keys) = logged_in.owner_keys.clone() else {
            return false;
        };
        let owner_pubkey = logged_in.owner_pubkey;
        let Some(local_app_keys) = self.app_keys.get(&owner_pubkey.to_hex()).cloned() else {
            return false;
        };
        let event = match self.signed_local_app_keys_snapshot(
            &known_app_keys_to_ndr(&local_app_keys),
            local_app_keys.created_at_secs,
            &owner_keys,
        ) {
            Ok(event) => event,
            Err(error) => {
                self.push_debug_log("publish.app_keys", error.to_string());
                return false;
            }
        };

        if self.capture_authorization_event(&event).is_err() {
            return false;
        }
        let published = self.publish_runtime_event(event, "app-keys", None);
        self.sync_local_app_keys_to_protocol_engine(label);
        published
    }
}